diff --git a/.claude/worktrees/agent-a98805dc618e0f67c b/.claude/worktrees/agent-a98805dc618e0f67c
deleted file mode 160000
index b4993b2..0000000
--- a/.claude/worktrees/agent-a98805dc618e0f67c
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit b4993b202deed0c14f4739b3ce363e8c63bb91b4
diff --git a/Backend/ERPCore.Tests/BankDepositServiceTests.cs b/Backend/ERPCore.Tests/BankDepositServiceTests.cs
new file mode 100644
index 0000000..837aaf7
--- /dev/null
+++ b/Backend/ERPCore.Tests/BankDepositServiceTests.cs
@@ -0,0 +1,211 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Accounts;
+using ERPCore.System.Errors;
+using ERPCore.Tests.TestSupport;
+using Microsoft.EntityFrameworkCore;
+using static ERPCore.Tests.TestSupport.BankDepositTestSupport;
+
+namespace ERPCore.Tests;
+
+/// <summary>Recording and cancelling bank deposits (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.2, §11).</summary>
+public class BankDepositServiceTests
+{
+    private static readonly DateOnly Today = Clock.Today;
+    private static readonly DateOnly Start = Today.AddDays(-10);
+    private static readonly DateOnly Day = Today.AddDays(-2);
+
+    [Fact]
+    public async Task Create_PostsBankDebitCashCredit_AndLowersCashInHand()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000));
+        await db.SaveChangesAsync();
+        var gl = new FakeGeneralLedger();
+
+        var dto = await DepositService(db, Start, gl).CreateAsync(Request(600, depositDate: Day.AddDays(1)));
+
+        Assert.Equal(BankDepositStatus.Posted, dto.Status);
+        Assert.Equal(("BOC Current", "Bank of Ceylon", "0001234567"), (dto.ToBankAccountName, dto.ToBankName, dto.ToAccountNumber));
+        Assert.Equal("JE-1", dto.GlJournalNo);
+
+        var entry = Assert.Single(gl.Posted);
+        Assert.Equal(Day.AddDays(1), entry.EntryDate);
+        Assert.Equal("BANK_DEPOSIT", entry.SourceModule);
+        Assert.Collection(entry.Lines,
+            l => Assert.Equal(("1010-01", 600m, 0m), (l.AccountCode, l.DebitAmount, l.CreditAmount)),
+            l => Assert.Equal(("1000-01", 0m, 600m), (l.AccountCode, l.DebitAmount, l.CreditAmount)));
+
+        var position = await CashService(db, Start).GetPositionAsync(Day, Branch1);
+        Assert.Equal((600m, 400m), (position.Position.Deposited, position.Position.Closing));
+    }
+
+    [Fact]
+    public async Task Create_MoreThanCashInHand_IsRejected()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000, card: 5000));
+        await db.SaveChangesAsync();
+        var gl = new FakeGeneralLedger();
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() => DepositService(db, Start, gl).CreateAsync(Request(1000.01m)));
+
+        Assert.Equal(ErrorCodes.BankDepositExceedsCashInHand, ex.Code);
+        Assert.Empty(gl.Posted);
+    }
+
+    [Fact]
+    public async Task Create_BackDatedDepositThatOverdrawsALaterDay_IsRejected()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000));
+        db.BankDeposits.Add(Deposit(Day.AddDays(1), 900));     // the next day already banked most of it
+        await db.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(Request(500)));
+
+        Assert.Equal(ErrorCodes.BankDepositExceedsCashInHand, ex.Code);
+        Assert.Contains("100.00", ex.Message);
+    }
+
+    [Fact]
+    public async Task Cancel_ReversesGl_AndPutsTheCashBack()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000));
+        await db.SaveChangesAsync();
+        var gl = new FakeGeneralLedger();
+        var service = DepositService(db, Start, gl);
+        var created = await service.CreateAsync(Request(1000));
+
+        var cancelled = await service.CancelAsync(created.BankDepositId, new CancelBankDepositRequest { Reason = " wrong bank " });
+
+        Assert.Equal(BankDepositStatus.Cancelled, cancelled.Status);
+        Assert.Equal("wrong bank", cancelled.CancelReason);
+        Assert.Equal("JE-2", cancelled.GlReversalJournalNo);
+        Assert.Collection(gl.Posted[1].Lines,
+            l => Assert.Equal(("1000-01", 1000m, 0m), (l.AccountCode, l.DebitAmount, l.CreditAmount)),
+            l => Assert.Equal(("1010-01", 0m, 1000m), (l.AccountCode, l.DebitAmount, l.CreditAmount)));
+        Assert.Equal(1000m, (await CashService(db, Start).GetPositionAsync(Day, Branch1)).Position.Closing);
+
+        var again = await Assert.ThrowsAsync<DomainException>(() =>
+            service.CancelAsync(created.BankDepositId, new CancelBankDepositRequest { Reason = "again" }));
+        Assert.Equal(ErrorCodes.BankDepositNotCancellable, again.Code);
+    }
+
+    [Theory]
+    [InlineData(FakeGeneralLedger.BankAccountId, FakeGeneralLedger.BankAccountId, ErrorCodes.BankDepositCashAccountInvalid)]
+    [InlineData(FakeGeneralLedger.CashAccountId, FakeGeneralLedger.CashAccountId, ErrorCodes.BankDepositBankAccountInvalid)]
+    [InlineData(99L, FakeGeneralLedger.BankAccountId, ErrorCodes.BankDepositCashAccountInvalid)]
+    public async Task Create_WrongAccountTypes_AreRejected(long from, long to, string code)
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000));
+        await db.SaveChangesAsync();
+
+        var request = Request(100);
+        request.FromGlCashAccountId = from;
+        request.ToGlBankAccountId = to;
+        var ex = await Assert.ThrowsAsync<DomainException>(() => DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(request));
+
+        Assert.Equal(code, ex.Code);
+    }
+
+    [Fact]
+    public async Task Create_CashAndBankAccountsSharingAnId_AreToldApartByType()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000));
+        await db.SaveChangesAsync();
+        // GL numbers cash and bank accounts in separate tables, so both can be account 1.
+        var gl = new FakeGeneralLedger
+        {
+            Accounts =
+            [
+                new("Cash", 1, "main", null, "Cash in Transit", "CASH-000001", 22, "1400-01-01", "LKR"),
+                new("Bank", 1, "Main - 01", "Commercial Bank", null, "2032434543", 2, "1000-01", "LKR")
+            ]
+        };
+        var request = Request(400);
+        request.FromGlCashAccountId = 1;
+        request.ToGlBankAccountId = 1;
+
+        var dto = await DepositService(db, Start, gl).CreateAsync(request);
+
+        Assert.Equal(("main", "Main - 01"), (dto.FromCashAccountName, dto.ToBankAccountName));
+        Assert.Collection(Assert.Single(gl.Posted).Lines,
+            l => Assert.Equal(("1000-01", 400m), (l.AccountCode, l.DebitAmount)),
+            l => Assert.Equal(("1400-01-01", 400m), (l.AccountCode, l.CreditAmount)));
+    }
+
+    [Fact]
+    public async Task Create_CannotUseAnotherBranchsCash()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000, warehouseId: Warehouse2));
+        await db.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(Request(100, branchId: Branch1)));
+
+        Assert.Equal(ErrorCodes.BankDepositExceedsCashInHand, ex.Code);
+    }
+
+    [Theory]
+    [InlineData(-11, null)]   // before tracking starts
+    [InlineData(1, null)]     // business date in the future
+    [InlineData(-2, -3)]      // deposited before the business day
+    [InlineData(-2, 2)]       // deposit date beyond tomorrow
+    public async Task Create_InvalidDates_AreRejected(int businessOffset, int? depositOffset)
+    {
+        await using var db = CreateContext();
+        var request = Request(100);
+        request.BusinessDate = Today.AddDays(businessOffset);
+        request.DepositDate = depositOffset is { } d ? Today.AddDays(d) : null;
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() => DepositService(db, Start, new FakeGeneralLedger()).CreateAsync(request));
+
+        Assert.Equal(ErrorCodes.BankDepositDateInvalid, ex.Code);
+    }
+
+    [Fact]
+    public async Task Create_GlRejection_LeavesNoDeposit()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.Add(CashSlip(Day, 1000));
+        await db.SaveChangesAsync();
+
+        await Assert.ThrowsAsync<DomainException>(() =>
+            DepositService(db, Start, new FakeGeneralLedger { Reject = true }).CreateAsync(Request(500)));
+
+        Assert.Equal(0, await db.BankDeposits.CountAsync());
+    }
+
+    [Fact]
+    public async Task List_FiltersAndTotalsEveryMatchingRow()
+    {
+        await using var db = CreateContext();
+        db.BankDeposits.AddRange(
+            Deposit(Day, 100), Deposit(Day, 200), Deposit(Day.AddDays(-1), 400),
+            Deposit(Day, 800, branchId: Branch2), Deposit(Day, 1600, status: BankDepositStatus.Cancelled));
+        await db.SaveChangesAsync();
+
+        var result = await DepositService(db, Start, new FakeGeneralLedger()).ListAsync(
+            new() { PageSize = 1 }, new BankDepositListFilter(Day, Day, Branch1, null, BankDepositStatus.Posted));
+
+        Assert.Single(result.Items);
+        Assert.Equal(2, result.Pagination.TotalItems);
+        Assert.Equal(300m, result.TotalAmount);
+    }
+
+    private static CreateBankDepositRequest Request(decimal amount, int branchId = Branch1, DateOnly? depositDate = null) => new()
+    {
+        BranchId = branchId,
+        BusinessDate = Day,
+        DepositDate = depositDate,
+        Amount = amount,
+        FromGlCashAccountId = FakeGeneralLedger.CashAccountId,
+        ToGlBankAccountId = FakeGeneralLedger.BankAccountId,
+        DepositSlipNo = "SLIP-1"
+    };
+}
diff --git a/Backend/ERPCore.Tests/CashInHandServiceTests.cs b/Backend/ERPCore.Tests/CashInHandServiceTests.cs
new file mode 100644
index 0000000..0241c10
--- /dev/null
+++ b/Backend/ERPCore.Tests/CashInHandServiceTests.cs
@@ -0,0 +1,134 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using static ERPCore.Tests.TestSupport.BankDepositTestSupport;
+
+namespace ERPCore.Tests;
+
+/// <summary>Till cash in hand (docs/BANK_DEPOSIT_MODULE_PLAN.md §2, §11).</summary>
+public class CashInHandServiceTests
+{
+    private static readonly DateOnly Today = Clock.Today;
+    private static readonly DateOnly Start = Today.AddDays(-10);
+
+    [Fact]
+    public async Task OnlyCashIsCounted()
+    {
+        await using var db = CreateContext();
+        var day = Today.AddDays(-2);
+        db.SalesSlips.AddRange(
+            CashSlip(day, cash: 300, card: 200),   // only the 300 is till cash
+            CashSlip(day, cash: 0, card: 900));
+        db.SalesInvoices.Add(new SalesInvoice
+        {
+            SalesInvoiceId = 1, InvoiceNo = "INV-1", InvoiceDate = At(day.AddDays(-5)), Status = SalesInvoiceStatus.Posted, BranchId = Branch1
+        });
+        db.SalesInvoicePayments.AddRange(
+            new SalesInvoicePayment { SalesInvoicePaymentId = 1, SalesInvoiceId = 1, PaymentDate = At(day), PaymentMethod = SalesPaymentMethod.Cash, Amount = 150 },
+            new SalesInvoicePayment { SalesInvoicePaymentId = 2, SalesInvoiceId = 1, PaymentDate = At(day), PaymentMethod = SalesPaymentMethod.Card, Amount = 500 },
+            new SalesInvoicePayment { SalesInvoicePaymentId = 3, SalesInvoiceId = 1, PaymentDate = At(day), PaymentMethod = SalesPaymentMethod.Cheque, Amount = 70 });
+        db.Expenses.Add(new Expense { ExpenseId = 1, DocNo = "EXP-1", BranchId = Branch1, ExpenseDate = day, Amount = 100, Status = ExpenseStatus.Posted });
+        db.ExpensePayments.AddRange(
+            new ExpensePayment { ExpensePaymentId = 1, ExpenseId = 1, PaymentDate = At(day), PaymentMethod = ExpensePaymentMethod.Cash, Amount = 40 },
+            new ExpensePayment { ExpensePaymentId = 2, ExpenseId = 1, PaymentDate = At(day), PaymentMethod = ExpensePaymentMethod.BankTransfer, Amount = 60 });
+        await db.SaveChangesAsync();
+
+        var p = (await CashService(db, Start).GetPositionAsync(day, Branch1)).Position;
+
+        Assert.Equal(450m, p.CashIn);
+        Assert.Equal(40m, p.CashOut);
+        Assert.Equal(410m, p.NetCash);
+        Assert.Equal(410m, p.Closing);
+    }
+
+    [Fact]
+    public async Task UndepositedCash_CarriesToTheNextDay_AndDepositsReduceIt()
+    {
+        await using var db = CreateContext();
+        var d1 = Today.AddDays(-3);
+        var d2 = Today.AddDays(-2);
+        db.SalesSlips.AddRange(CashSlip(d1, 1000), CashSlip(d2, 500));
+        db.BankDeposits.AddRange(
+            Deposit(d1, 600),
+            Deposit(d1, 999, status: BankDepositStatus.Cancelled));   // ignored
+        await db.SaveChangesAsync();
+
+        var days = (await CashService(db, Start).GetDailyAsync(d1, d2, Branch1)).Days;
+
+        Assert.Equal((0m, 1000m, 600m, 400m), (days[0].Opening, days[0].NetCash, days[0].Deposited, days[0].Closing));
+        Assert.Equal((400m, 500m, 0m, 900m), (days[1].Opening, days[1].NetCash, days[1].Deposited, days[1].Closing));
+    }
+
+    [Fact]
+    public async Task Opening_IsCarriedInFromBeforeTheWindow()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.AddRange(CashSlip(Today.AddDays(-6), 700), CashSlip(Today.AddDays(-5), 300));
+        db.BankDeposits.Add(Deposit(Today.AddDays(-5), 200));
+        await db.SaveChangesAsync();
+
+        var day = (await CashService(db, Start).GetPositionAsync(Today.AddDays(-1), Branch1)).Position;
+
+        Assert.Equal(800m, day.Opening);
+        Assert.Equal(800m, day.Closing);
+    }
+
+    [Fact]
+    public async Task CashBeforeTheTrackingStart_IsNotCarried()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.AddRange(CashSlip(Start.AddDays(-1), 5000), CashSlip(Start, 100));
+        await db.SaveChangesAsync();
+
+        var days = (await CashService(db, Start).GetDailyAsync(Start.AddDays(-1), Start, Branch1)).Days;
+
+        Assert.Equal(5000m, days[0].NetCash);      // still reported for the day itself
+        Assert.Equal(0m, days[1].Opening);         // but not carried into tracking
+        Assert.Equal(100m, days[1].Closing);
+    }
+
+    [Fact]
+    public async Task Available_IsTheLowestClosingFromThatDayToToday()
+    {
+        await using var db = CreateContext();
+        var d1 = Today.AddDays(-2);
+        db.SalesSlips.Add(CashSlip(d1, 1000));
+        db.BankDeposits.Add(Deposit(Today.AddDays(-1), 800));      // already took most of it the next day
+        await db.SaveChangesAsync();
+
+        var position = await CashService(db, Start).GetPositionAsync(d1, Branch1);
+
+        Assert.Equal(1000m, position.Position.Closing);
+        Assert.Equal(200m, position.AvailableToDeposit);
+    }
+
+    [Fact]
+    public async Task Branches_AreKeptApart()
+    {
+        await using var db = CreateContext();
+        var day = Today.AddDays(-1);
+        db.SalesSlips.AddRange(CashSlip(day, 100, warehouseId: Warehouse1), CashSlip(day, 900, warehouseId: Warehouse2));
+        await db.SaveChangesAsync();
+
+        var service = CashService(db, Start);
+
+        Assert.Equal(100m, (await service.GetPositionAsync(day, Branch1)).Position.Closing);
+        Assert.Equal(900m, (await service.GetPositionAsync(day, Branch2)).Position.Closing);
+        Assert.Equal(1000m, (await service.GetPositionAsync(day, null)).Position.Closing);
+    }
+
+    [Fact]
+    public async Task LateEveningSale_CountsOnTheLocalDay()
+    {
+        await using var db = CreateContext();
+        var day = Today.AddDays(-1);
+        var slip = CashSlip(day, 250);
+        slip.SlipDate = Clock.ToUtc(day.AddDays(1)).AddMinutes(-30);    // 23:30 local
+        db.SalesSlips.Add(slip);
+        await db.SaveChangesAsync();
+
+        var days = (await CashService(db, Start).GetDailyAsync(day, day.AddDays(1), Branch1)).Days;
+
+        Assert.Equal(250m, days[0].CashIn);
+        Assert.Equal(0m, days[1].CashIn);
+    }
+}
diff --git a/Backend/ERPCore.Tests/DayEndReportServiceTests.cs b/Backend/ERPCore.Tests/DayEndReportServiceTests.cs
new file mode 100644
index 0000000..bf9613c
--- /dev/null
+++ b/Backend/ERPCore.Tests/DayEndReportServiceTests.cs
@@ -0,0 +1,257 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.Persistence;
+using ERPCore.Repositories;
+using ERPCore.Services;
+using ERPCore.System.Errors;
+using ERPCore.Tests.TestSupport;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.Extensions.Configuration;
+
+namespace ERPCore.Tests;
+
+/// <summary>Aggregates of the Day-End Sales Report (docs/DAY_END_SALES_REPORT_PLAN.md §7).</summary>
+public class DayEndReportServiceTests
+{
+    private static readonly InMemoryDatabaseRoot Root = new();
+
+    // Asia/Colombo is UTC+05:30 all year (no DST), so local midnight is 18:30 UTC the day before.
+    private static readonly DateOnly Day = new(2026, 10, 8);
+    private static DateTime UtcAt(int hour, int minute = 0) => new(2026, 10, 8, hour, minute, 0, DateTimeKind.Utc);
+
+    [Fact]
+    public async Task Day_MixOfSlipsBundlesAndInvoices_TotalsAndSplitsByMethod()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.AddRange(
+            Slip(1, UtcAt(5), total: 1000, paid: 600, cash: 400, card: 200),   // partial, mixed
+            Slip(2, UtcAt(6), total: 200, paid: 200, cash: 200, card: 0),      // all cash
+            Slip(3, UtcAt(7), total: 999, paid: 999, cash: 999, card: 0, status: SalesSlipStatus.Draft));
+        db.BundleSales.Add(new BundleSale { BundleSaleId = 1, BundleDate = UtcAt(8), Status = BundleSaleStatus.Posted, GrandTotal = 500, CashAmount = 0, CardAmount = 500 });
+        db.SalesInvoices.Add(Invoice(1, UtcAt(9), netPayable: 2000, paid: 1500));
+        db.SalesInvoicePayments.AddRange(
+            Payment(1, invoiceId: 1, UtcAt(9), SalesPaymentMethod.Cash, 500),
+            Payment(2, invoiceId: 1, UtcAt(10), SalesPaymentMethod.Card, 1000));
+        SeedExpenseSetup(db);
+        db.Expenses.AddRange(
+            Expense(1, Day, 300, ExpenseStatus.Posted),
+            Expense(2, Day, 700, ExpenseStatus.Cancelled),
+            Expense(3, Day.AddDays(1), 50, ExpenseStatus.Posted));
+        await db.SaveChangesAsync();
+
+        var report = await CreateService(db).GetDayAsync(Day, null);
+        var s = report.Summary;
+
+        Assert.Equal(3700m, s.TotalSales);
+        Assert.Equal(2800m, s.PaidAmount);
+        Assert.Equal(900m, s.DueAmount);
+        Assert.Equal(1100m, s.PaidByCash);
+        Assert.Equal(1700m, s.PaidByCard);
+        Assert.Equal(0m, s.PaidByOther);
+        Assert.Equal(4, s.SalesCount);
+        Assert.Equal(1, s.CashSalesCount);
+        Assert.Equal(1, s.CardSalesCount);
+        Assert.Equal(2, s.MixedSalesCount);
+        Assert.Equal(0, s.UnpaidSalesCount);
+        Assert.Equal(300m, s.ExpenseTotal);
+        Assert.Equal(3400m, s.Income);
+        Assert.Single(report.Expenses);
+        Assert.Equal("Electricity", report.Expenses[0].TitleName);
+    }
+
+    [Fact]
+    public async Task Day_SaleLateInTheLocalEvening_CountsOnTheLocalDay()
+    {
+        await using var db = CreateContext();
+        // 19:00 UTC on Oct 7 is 00:30 on Oct 8 in Colombo; 18:00 UTC on Oct 8 is 23:30 on Oct 8.
+        db.SalesSlips.AddRange(
+            Slip(1, new DateTime(2026, 10, 7, 19, 0, 0, DateTimeKind.Utc), total: 100, paid: 100, cash: 100, card: 0),
+            Slip(2, new DateTime(2026, 10, 8, 18, 0, 0, DateTimeKind.Utc), total: 40, paid: 40, cash: 40, card: 0),
+            Slip(3, new DateTime(2026, 10, 8, 19, 0, 0, DateTimeKind.Utc), total: 7, paid: 7, cash: 7, card: 0));
+        await db.SaveChangesAsync();
+
+        var report = await CreateService(db).GetDailyAsync(Day.AddDays(-1), Day.AddDays(1), null);
+
+        Assert.Equal([0m, 140m, 7m], report.Days.Select(d => d.TotalSales));
+        Assert.Equal(147m, report.Totals.TotalSales);
+    }
+
+    [Fact]
+    public async Task Day_PaymentOnAnEarlierInvoice_IsACollectionAndCountsInNetCash()
+    {
+        await using var db = CreateContext();
+        db.SalesInvoices.Add(Invoice(1, UtcAt(5).AddDays(-3), netPayable: 800, paid: 250));
+        db.SalesInvoicePayments.Add(Payment(1, invoiceId: 1, UtcAt(6), SalesPaymentMethod.Cash, 250));
+        db.SalesSlips.Add(Slip(1, UtcAt(7), total: 60, paid: 60, cash: 60, card: 0));
+        SeedExpenseSetup(db);
+        db.Expenses.Add(Expense(1, Day, 30, ExpenseStatus.Posted));
+        db.ExpensePayments.Add(new ExpensePayment { ExpensePaymentId = 1, ExpenseId = 1, Amount = 30, PaymentDate = UtcAt(8), PaymentMethod = ExpensePaymentMethod.Cash });
+        await db.SaveChangesAsync();
+
+        var s = (await CreateService(db).GetDayAsync(Day, null)).Summary;
+
+        Assert.Equal(60m, s.TotalSales);
+        Assert.Equal(60m, s.PaidAmount);
+        Assert.Equal(250m, s.EarlierInvoiceCollections);
+        Assert.Equal(60m + 250m - 30m, s.NetCash);
+    }
+
+    [Fact]
+    public async Task Day_ShowsBankDepositsAndTheCashLeftInHand()
+    {
+        await using var db = CreateContext();
+        db.SalesSlips.AddRange(
+            Slip(1, UtcAt(5).AddDays(-1), total: 300, paid: 300, cash: 300, card: 0),   // yesterday, never banked
+            Slip(2, UtcAt(6), total: 1000, paid: 1000, cash: 1000, card: 0));
+        db.BankDeposits.AddRange(
+            BankDeposit(1, Day, 800, BankDepositStatus.Posted),
+            BankDeposit(2, Day, 5000, BankDepositStatus.Cancelled));
+        await db.SaveChangesAsync();
+
+        var report = await CreateService(db).GetDayAsync(Day, null);
+        var s = report.Summary;
+
+        Assert.Equal((300m, 1000m, 800m, 500m), (s.OpeningCashInHand, s.NetCash, s.CashDeposited, s.ClosingCashInHand));
+        var deposit = Assert.Single(report.Deposits);
+        Assert.Equal(("BD-1", "BOC Current", 800m), (deposit.DocNo, deposit.BankAccountName, deposit.Amount));
+
+        var range = await CreateService(db).GetDailyAsync(Day.AddDays(-1), Day, null);
+        Assert.Equal((0m, 800m, 500m), (range.Totals.OpeningCashInHand, range.Totals.CashDeposited, range.Totals.ClosingCashInHand));
+    }
+
+    [Fact]
+    public async Task Day_Profit_IsSalesLessStockCostLessExpenses_AndCanBeALoss()
+    {
+        await using var db = CreateContext();
+        db.SalesInvoices.Add(Invoice(1, UtcAt(5), netPayable: 1000, paid: 1000));
+        db.SalesInvoicePayments.Add(Payment(1, invoiceId: 1, UtcAt(5), SalesPaymentMethod.Card, 1000));
+        db.SalesSlips.Add(Slip(1, UtcAt(6), total: 200, paid: 0, cash: 0, card: 0));
+        db.StockLedger.AddRange(
+            Ledger(1, DocumentTypes.SalesInvoice, 1, Direction.Out, 600),
+            Ledger(2, DocumentTypes.SalesInvoice, 1, Direction.Out, 100),
+            Ledger(3, DocumentTypes.SalesSlip, 1, Direction.Out, 150),
+            Ledger(4, DocumentTypes.SalesInvoice, 1, Direction.In, 999));   // not a sale's cost
+        SeedExpenseSetup(db);
+        db.Expenses.Add(Expense(1, Day, 900, ExpenseStatus.Posted));
+        await db.SaveChangesAsync();
+
+        var report = await CreateService(db).GetDayAsync(Day, null);
+        var s = report.Summary;
+
+        Assert.Equal(850m, s.CostOfGoodsSold);
+        Assert.Equal(350m, s.GrossProfit);
+        Assert.Equal(-550m, s.NetProfit);
+        Assert.Equal(2, report.Sales.Count);
+        var invoice = report.Sales.Single(x => x.DocType == "Invoice");
+        Assert.Equal(("Card", 700m, 300m), (invoice.PaidBy, invoice.Cost, invoice.GrossProfit));
+        Assert.Equal("Unpaid", report.Sales.Single(x => x.DocType == "Slip").PaidBy);
+    }
+
+    [Fact]
+    public async Task Day_UnpaidInvoice_CountsAsUnpaidAndDue()
+    {
+        await using var db = CreateContext();
+        db.SalesInvoices.Add(Invoice(1, UtcAt(5), netPayable: 450, paid: 0));
+        await db.SaveChangesAsync();
+
+        var s = (await CreateService(db).GetDayAsync(Day, null)).Summary;
+
+        Assert.Equal(1, s.UnpaidSalesCount);
+        Assert.Equal(450m, s.DueAmount);
+    }
+
+    [Fact]
+    public async Task Daily_FillsQuietDaysWithZeros()
+    {
+        await using var db = CreateContext();
+        var report = await CreateService(db).GetDailyAsync(Day, Day.AddDays(4), null);
+
+        Assert.Equal(5, report.Days.Count);
+        Assert.All(report.Days, d => Assert.Equal(0m, d.Income));
+        Assert.Equal(Day.AddDays(4), report.Days[^1].Date);
+    }
+
+    [Theory]
+    [InlineData(1, 0)]   // to before from
+    [InlineData(0, 92)]  // 93 days
+    public async Task Daily_InvalidRange_IsRejected(int fromOffset, int toOffset)
+    {
+        await using var db = CreateContext();
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            CreateService(db).GetDailyAsync(Day.AddDays(fromOffset), Day.AddDays(toOffset), null));
+
+        Assert.Equal(ErrorCodes.DayEndReportRangeInvalid, ex.Code);
+    }
+
+    // --- helpers ------------------------------------------------------------------------------
+
+    private static SalesSlip Slip(int id, DateTime at, decimal total, decimal paid, decimal cash, decimal card,
+        SalesSlipStatus status = SalesSlipStatus.Posted) => new()
+    {
+        SalesSlipId = id, SlipNo = $"SL-{id}", SlipDate = at, Status = status,
+        GrandTotal = total, PaidAmount = paid, BalanceAmount = total - paid, CashAmount = cash, CardAmount = card
+    };
+
+    private static SalesInvoice Invoice(int id, DateTime at, decimal netPayable, decimal paid) => new()
+    {
+        SalesInvoiceId = id, InvoiceNo = $"INV-{id}", InvoiceDate = at, Status = SalesInvoiceStatus.Posted,
+        GrandTotal = netPayable, NetPayable = netPayable, PaidAmount = paid, BalanceAmount = netPayable - paid
+    };
+
+    private static SalesInvoicePayment Payment(int id, int invoiceId, DateTime at, SalesPaymentMethod method, decimal amount) => new()
+    {
+        SalesInvoicePaymentId = id, SalesInvoiceId = invoiceId, PaymentDate = at, PaymentMethod = method, Amount = amount
+    };
+
+    private static StockLedger Ledger(int id, string docType, int docId, Direction direction, decimal value) => new()
+    {
+        LedgerId = id, SourceDocType = docType, SourceDocId = docId, Direction = direction, Value = value, QtyBase = 1, ItemId = 1, WarehouseId = 1
+    };
+
+    private static Expense Expense(int id, DateOnly date, decimal amount, ExpenseStatus status) => new()
+    {
+        ExpenseId = id, DocNo = $"EXP-{id}", ExpenseDate = date, Amount = amount, Status = status,
+        ExpenseCategoryId = 1, ExpenseTitleId = 1
+    };
+
+    private static BankDeposit BankDeposit(int id, DateOnly businessDate, decimal amount, BankDepositStatus status) => new()
+    {
+        BankDepositId = id, DocNo = $"BD-{id}", BranchId = 1, BusinessDate = businessDate, DepositDate = businessDate, Amount = amount,
+        Status = status, FromCashAccountCode = "1000-01", FromCashAccountName = "Main Till",
+        ToBankAccountCode = "1010-01", ToBankAccountName = "BOC Current"
+    };
+
+    private static void SeedExpenseSetup(ErpDbContext db)
+    {
+        db.ExpenseCategories.Add(new ExpenseCategory { ExpenseCategoryId = 1, Code = "UTILITY", Name = "Utility" });
+        db.ExpenseTitles.Add(new ExpenseTitle { ExpenseTitleId = 1, ExpenseCategoryId = 1, Name = "Electricity", GlExpenseAccountCode = "5200-01" });
+    }
+
+    private static DayEndReportService CreateService(ErpDbContext db)
+    {
+        var config = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?> { ["DayEndReport:TimeZone"] = "Asia/Colombo" })
+            .Build();
+        var clock = new BusinessDayClock(config);
+        var branch = new CurrentBranchContext(new TestCurrentUser());
+        var cash = new CashInHandService(
+            new Repository<SalesSlip>(db), new Repository<BundleSale>(db), new Repository<SalesInvoicePayment>(db),
+            new Repository<ExpensePayment>(db), new Repository<BankDeposit>(db), branch, clock, config);
+        return new DayEndReportService(
+            new Repository<SalesSlip>(db), new Repository<BundleSale>(db), new Repository<SalesInvoice>(db),
+            new Repository<SalesInvoicePayment>(db), new Repository<StockLedger>(db),
+            new Repository<Expense>(db), new Repository<BankDeposit>(db), cash, branch, clock);
+    }
+
+    private static ErpDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ErpDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
+            .Options;
+        var currentUser = new TestCurrentUser();
+        return new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
+    }
+}
diff --git a/Backend/ERPCore.Tests/DualApprovalTests.cs b/Backend/ERPCore.Tests/DualApprovalTests.cs
new file mode 100644
index 0000000..638f4f0
--- /dev/null
+++ b/Backend/ERPCore.Tests/DualApprovalTests.cs
@@ -0,0 +1,392 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Approvals;
+using ERPCore.Dtos.Notifications;
+using ERPCore.Dtos.Products;
+using ERPCore.Dtos.Stock;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.Persistence;
+using ERPCore.Repositories;
+using ERPCore.Services;
+using ERPCore.Services.Gl;
+using ERPCore.Services.Interfaces;
+using ERPCore.Services.Stock;
+using ERPCore.System.Errors;
+using ERPCore.Tests.TestSupport;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.Extensions.Configuration;
+
+namespace ERPCore.Tests;
+
+/// <summary>Dual approval of stock and price adjustments (docs/DUAL_APPROVAL_PLAN.md §13).</summary>
+public class DualApprovalTests
+{
+    private static readonly InMemoryDatabaseRoot Root = new();
+
+    // Requester, two approvers, and a clerk who can approve but isn't a manager.
+    private const int Requester = 10, ApproverA = 11, ApproverB = 12, Clerk = 13;
+    private const int ApproverRoleId = 2, ClerkRoleId = 3;
+    private const int ItemId = 1, WarehouseId = 1, ReasonId = 1;
+
+    // --- Stock adjustments ------------------------------------------------------------------
+
+    [Fact]
+    public async Task StockAdjustment_IsARequest_NothingMovesUntilApproved()
+    {
+        var h = await Harness.CreateAsync();
+
+        var dto = await h.Stock.CreateAsync(Request(-3));
+
+        Assert.Equal(AdjustmentStatus.PendingApproval, dto.Status);
+        Assert.Equal(2, dto.RequiredApprovals);
+        Assert.Equal(1, dto.PendingLevel);
+        Assert.Empty(h.Mutator.Calls);
+        Assert.Empty(h.Gl.Posted);
+        var pending = Assert.Single(h.Notifications.Targeted, n => n.ModuleKey == "approval.pending");
+        Assert.Equal([ApproverA, ApproverB, Clerk], pending.UserIds.Order());   // never the requester
+    }
+
+    [Fact]
+    public async Task StockAdjustment_TwoDifferentApprovers_ThenItPosts()
+    {
+        var h = await Harness.CreateAsync();
+        var id = (await h.Stock.CreateAsync(Request(-3))).AdjustmentId;
+
+        h.User.Be(Requester);
+        var own = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
+        Assert.Equal(ErrorCodes.ApprovalForbidden, own.Code);
+
+        h.User.Be(ApproverA);
+        var first = await h.Stock.ApproveAsync(id, "counted twice");
+        Assert.Equal(AdjustmentStatus.PendingSecondApproval, first.Status);
+        Assert.Empty(h.Mutator.Calls);
+
+        var twice = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
+        Assert.Equal(ErrorCodes.ApprovalSamePerson, twice.Code);
+
+        h.User.Be(ApproverB);
+        var posted = await h.Stock.ApproveAsync(id, null);
+
+        Assert.Equal(AdjustmentStatus.Posted, posted.Status);
+        Assert.Equal((ApproverA, ApproverB), (posted.ApprovedLevel1By, posted.ApprovedLevel2By));
+        var call = Assert.Single(h.Mutator.Calls);
+        Assert.Equal(-3m, Assert.Single(call).QtyDelta);
+        Assert.Single(h.Gl.Posted);
+        Assert.NotNull(posted.PostedAt);
+        Assert.Equal([1, 2], posted.ApprovalHistory!.Select(s => s.Level));
+        Assert.Contains(h.Notifications.Targeted, n => n.ModuleKey == "approval.approved" && n.UserIds.SequenceEqual([Requester]));
+    }
+
+    [Fact]
+    public async Task StockAdjustment_Rejected_NeedsAReason_AndNeverPosts()
+    {
+        var h = await Harness.CreateAsync();
+        var id = (await h.Stock.CreateAsync(Request(5))).AdjustmentId;
+        h.User.Be(ApproverA);
+
+        var noReason = await Assert.ThrowsAsync<DomainException>(() => h.Stock.RejectAsync(id, " "));
+        Assert.Equal(ErrorCodes.ApprovalReasonRequired, noReason.Code);
+
+        var rejected = await h.Stock.RejectAsync(id, "wrong warehouse");
+        Assert.Equal((AdjustmentStatus.Rejected, "wrong warehouse"), (rejected.Status, rejected.RejectReason));
+
+        h.User.Be(ApproverB);
+        var late = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
+        Assert.Equal(ErrorCodes.ApprovalNotPending, late.Code);
+        Assert.Empty(h.Mutator.Calls);
+        Assert.Contains(h.Notifications.Targeted, n => n.ModuleKey == "approval.rejected");
+    }
+
+    [Fact]
+    public async Task StockAdjustment_ApprovalsOff_PostsOnCreate()
+    {
+        var h = await Harness.CreateAsync(stockLevels: 0);
+
+        var dto = await h.Stock.CreateAsync(Request(2));
+
+        Assert.Equal((AdjustmentStatus.Posted, 0), (dto.Status, dto.RequiredApprovals));
+        Assert.Single(h.Mutator.Calls);
+    }
+
+    [Fact]
+    public async Task StockAdjustment_BelowTheValueThreshold_NeedsOneApproval()
+    {
+        // 3 units at 10.00 each = 30.00, below the 1,000 threshold.
+        var h = await Harness.CreateAsync(stockThreshold: 1000);
+        var id = (await h.Stock.CreateAsync(Request(-3))).AdjustmentId;
+
+        h.User.Be(ApproverA);
+        var posted = await h.Stock.ApproveAsync(id, null);
+
+        Assert.Equal((AdjustmentStatus.Posted, 1), (posted.Status, posted.RequiredApprovals));
+        Assert.Single(h.Mutator.Calls);
+    }
+
+    [Fact]
+    public async Task StockAdjustment_OnlyTheRequesterCanWithdraw()
+    {
+        var h = await Harness.CreateAsync();
+        var id = (await h.Stock.CreateAsync(Request(-1))).AdjustmentId;
+
+        h.User.Be(ApproverA);
+        var other = await Assert.ThrowsAsync<DomainException>(() => h.Stock.CancelAsync(id));
+        Assert.Equal(ErrorCodes.ApprovalForbidden, other.Code);
+
+        h.User.Be(Requester);
+        Assert.Equal(AdjustmentStatus.Cancelled, (await h.Stock.CancelAsync(id)).Status);
+    }
+
+    [Fact]
+    public async Task SecondApproval_CanBeLimitedToRoles()
+    {
+        var h = await Harness.CreateAsync(level2Roles: "Approver");
+        var id = (await h.Stock.CreateAsync(Request(-1))).AdjustmentId;
+        h.User.Be(ApproverA);
+        await h.Stock.ApproveAsync(id, null);
+
+        h.User.Be(Clerk);
+        var clerk = await Assert.ThrowsAsync<DomainException>(() => h.Stock.ApproveAsync(id, null));
+        Assert.Equal(ErrorCodes.ApprovalRoleRequired, clerk.Code);
+
+        h.User.Be(ApproverB);
+        Assert.Equal(AdjustmentStatus.Posted, (await h.Stock.ApproveAsync(id, null)).Status);
+    }
+
+    // --- Price adjustments ------------------------------------------------------------------
+
+    [Fact]
+    public async Task PriceAdjustment_AppliesOnlyAfterTheSecondApproval_AndKeepsHistory()
+    {
+        var h = await Harness.CreateAsync();
+        var dto = await h.Prices.CreateAsync(PriceRequest(flat: 120m));
+        Assert.Equal(PriceAdjustmentStatus.PendingApproval, dto.Status);
+        Assert.Equal(100m, (await h.Db.Items.AsNoTracking().FirstAsync()).SellingFlatPrice);
+
+        h.User.Be(ApproverA);
+        await h.Prices.ApproveAsync(dto.PriceAdjustmentId, null);
+        Assert.Equal(100m, (await h.Db.Items.AsNoTracking().FirstAsync()).SellingFlatPrice);
+
+        h.User.Be(ApproverB);
+        var applied = await h.Prices.ApproveAsync(dto.PriceAdjustmentId, null);
+
+        Assert.Equal(PriceAdjustmentStatus.Approved, applied.Status);
+        Assert.Equal(120m, (await h.Db.Items.AsNoTracking().FirstAsync()).SellingFlatPrice);
+        var history = Assert.Single(await h.Prices.ItemHistoryAsync(ItemId));
+        Assert.Equal((100m, 120m, ApproverA, ApproverB, dto.DocNo), (history.OldFlatPrice, history.NewFlatPrice, history.ApprovedLevel1By, history.ApprovedLevel2By, history.DocNo));
+    }
+
+    [Fact]
+    public async Task PriceAdjustment_ItemRepricedSinceTheRequest_IsRefusedAsStale()
+    {
+        var h = await Harness.CreateAsync();
+        var id = (await h.Prices.CreateAsync(PriceRequest(flat: 120m))).PriceAdjustmentId;
+        h.User.Be(ApproverA);
+        await h.Prices.ApproveAsync(id, null);
+
+        var item = await h.Db.Items.FirstAsync();
+        item.SellingFlatPrice = 105m;            // someone changed it in between
+        await h.Db.SaveChangesAsync();
+
+        h.User.Be(ApproverB);
+        var stale = await Assert.ThrowsAsync<DomainException>(() => h.Prices.ApproveAsync(id, null));
+        Assert.Equal(ErrorCodes.PriceAdjustmentStale, stale.Code);
+        Assert.Empty(await h.Prices.ItemHistoryAsync(ItemId));
+    }
+
+    [Fact]
+    public async Task PriceAdjustment_OnePendingRequestPerItem()
+    {
+        var h = await Harness.CreateAsync();
+        await h.Prices.CreateAsync(PriceRequest(flat: 120m));
+
+        var second = await Assert.ThrowsAsync<DomainException>(() => h.Prices.CreateAsync(PriceRequest(flat: 130m)));
+        Assert.Equal(ErrorCodes.PriceAdjustmentItemPending, second.Code);
+    }
+
+    [Theory]
+    [InlineData(100, 120, 20)]
+    [InlineData(100, 80, 20)]
+    [InlineData(-1, 50, 100)]     // setting a price where there was none (-1 = no price)
+    [InlineData(50, -1, 100)]     // clearing one
+    [InlineData(40, 40, 0)]
+    public void ChangePercent_MeasuresTheSizeOfAPriceChange(int oldPrice, int newPrice, int expected)
+    {
+        decimal? Price(int v) => v < 0 ? null : v;
+        Assert.Equal(expected, PriceAdjustmentService.ChangePercent(Price(oldPrice), Price(newPrice)));
+    }
+
+    [Theory]
+    [InlineData(2, 0, 5000, 2)]     // no threshold: always two
+    [InlineData(2, 1000, 50, 1)]    // below threshold: one
+    [InlineData(2, 1000, 1000, 2)]  // at threshold: two
+    [InlineData(1, 1000, 5000, 1)]
+    [InlineData(0, 0, 5000, 0)]
+    public void RequiredLevels_FollowTheSettings(int configured, double threshold, double measure, int expected)
+        => Assert.Equal(expected, ApprovalService.Levels(configured, (decimal)threshold, (decimal)measure));
+
+    // --- helpers ------------------------------------------------------------------------------
+
+    private static CreateAdjustmentRequest Request(decimal qty) => new()
+    {
+        WarehouseId = WarehouseId, BranchId = 1, ReasonCodeId = ReasonId,
+        Lines = [new CreateAdjustmentLineInput { ItemId = ItemId, QtyDelta = qty }]
+    };
+
+    private static CreatePriceAdjustmentRequest PriceRequest(decimal flat) => new()
+    {
+        Reason = "Supplier price rise",
+        Lines = [new PriceAdjustmentLineInput { ItemId = ItemId, NewMinPrice = 90m, NewMaxPrice = 150m, NewFlatPrice = flat }]
+    };
+
+    private sealed class Harness
+    {
+        public required ErpDbContext Db { get; init; }
+        public required SwitchableUser User { get; init; }
+        public required RecordingMutator Mutator { get; init; }
+        public required FakeGeneralLedger Gl { get; init; }
+        public required RecordingNotifications Notifications { get; init; }
+        public required AdjustmentService Stock { get; init; }
+        public required PriceAdjustmentService Prices { get; init; }
+
+        public static async Task<Harness> CreateAsync(int stockLevels = 2, decimal stockThreshold = 0, string? level2Roles = null)
+        {
+            var db = new ErpDbContext(
+                new DbContextOptionsBuilder<ErpDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root).Options,
+                new TestCurrentUser(), new CurrentBranchContext(new TestCurrentUser()));
+
+            db.Roles.AddRange(
+                new Role { RoleId = 1, Code = "Requester", Name = "Requester" },
+                new Role { RoleId = ApproverRoleId, Code = "Approver", Name = "Approver" },
+                new Role { RoleId = ClerkRoleId, Code = "Clerk", Name = "Clerk" });
+            db.Users.AddRange(
+                new User { UserId = ERPCore.Domain.Entities.User.SystemUserId, Username = "system", DisplayName = "System" },
+                new User { UserId = Requester, Username = "req", DisplayName = "Requester", RoleId = 1 },
+                new User { UserId = ApproverA, Username = "a", DisplayName = "Approver A", RoleId = ApproverRoleId },
+                new User { UserId = ApproverB, Username = "b", DisplayName = "Approver B", RoleId = ApproverRoleId },
+                new User { UserId = Clerk, Username = "c", DisplayName = "Clerk", RoleId = ClerkRoleId });
+            db.Permissions.AddRange(
+                new Permission { PermissionId = 45, Code = "NAV:stock.adjustments" },
+                new Permission { PermissionId = 58, Code = "NAV:products.price-adjustments" });
+            foreach (var roleId in new[] { ApproverRoleId, ClerkRoleId })
+            foreach (var permissionId in new[] { 45, 58 })
+                db.RolePermissions.Add(new RolePermission { RoleId = roleId, PermissionId = permissionId, Actions = RolePermissionAction.All });
+            db.RolePermissions.Add(new RolePermission { RoleId = 1, PermissionId = 45, Actions = RolePermissionAction.View | RolePermissionAction.Create });
+
+            db.Branches.Add(new Branch { BranchId = 1, Code = "BR-001", Name = "Main" });
+            db.Warehouses.Add(new Warehouse { WarehouseId = WarehouseId, Code = "WH-1", Name = "Main Store", BranchId = 1 });
+            db.Uoms.Add(new Uom { UomId = 1, Name = "pcs" });
+            db.Items.Add(new Item { ItemId = ItemId, Sku = "SKU-1", Name = "Cola", BaseUomId = 1, CategoryId = 1,
+                SellingMinPrice = 90m, SellingMaxPrice = 150m, SellingFlatPrice = 100m });
+            db.ReasonCodes.Add(new ReasonCode { ReasonCodeId = ReasonId, Code = "DMG", Description = "Damage", Context = ReasonContext.Adjustment });
+            db.ApprovalConfig.Add(new ApprovalConfig
+            {
+                ApprovalConfigId = ApprovalConfig.SingletonId, StockAdjustmentLevels = stockLevels,
+                StockAdjustmentLevel2ThresholdValue = stockThreshold, PriceAdjustmentLevels = 2, Level2RoleCodes = level2Roles
+            });
+            await db.SaveChangesAsync();
+
+            var user = new SwitchableUser(Requester, "Requester");
+            var uow = new PassThroughUnitOfWork(db);
+            var notifications = new RecordingNotifications();
+            var approvals = new ApprovalService(
+                new Repository<ApprovalConfig>(db), new Repository<DocumentApproval>(db), new Repository<User>(db),
+                new Repository<RolePermission>(db), user, notifications, uow);
+            var gl = new FakeGeneralLedger();
+            var mutator = new RecordingMutator();
+            var numbers = new FakeNumberSequence();
+
+            var stock = new AdjustmentService(
+                new Repository<StockAdjustment>(db), new Repository<Warehouse>(db), new Repository<Item>(db),
+                new Repository<ReasonCode>(db), new Repository<StockLedger>(db), mutator, new FixedValuation(),
+                numbers, user, new FakeBranchConfig(), notifications, approvals, uow, db, gl,
+                new StubGlAccountConfigService(
+                    (GlAccountRole.Inventory, "1200"),
+                    (GlAccountRole.InventoryGain, "4900"),
+                    (GlAccountRole.InventoryLoss, "5900")),
+                new SerialTrackingService(new Repository<Serial>(db), new Repository<SerialMovement>(db), new Repository<StockLayer>(db),
+                    new Repository<ProductConfig>(db), user));
+            var prices = new PriceAdjustmentService(
+                new Repository<PriceAdjustment>(db), new Repository<Item>(db), new Repository<ItemPriceHistory>(db),
+                new Repository<User>(db), new Repository<ApprovalConfig>(db), approvals, notifications, numbers, user, uow);
+
+            return new Harness { Db = db, User = user, Mutator = mutator, Gl = gl, Notifications = notifications, Stock = stock, Prices = prices };
+        }
+    }
+
+    /// <summary>A signed-in user whose identity the test switches between steps.</summary>
+    private sealed class SwitchableUser(int userId, string roleCode) : ICurrentUser
+    {
+        private static readonly Dictionary<int, string> Roles = new()
+        {
+            [Requester] = "Requester", [ApproverA] = "Approver", [ApproverB] = "Approver", [Clerk] = "Clerk"
+        };
+
+        public int AuditUserId { get; private set; } = userId;
+        public string? RoleCode { get; private set; } = roleCode;
+        public string UserId => AuditUserId.ToString();
+        public bool IsAuthenticated => true;
+        public bool IsAdmin => false;
+        public int? BranchId => null;
+
+        public void Be(int userId)
+        {
+            AuditUserId = userId;
+            RoleCode = Roles[userId];
+        }
+    }
+
+    /// <summary>Records what would be posted to stock; every unit is worth 10.00.</summary>
+    private sealed class RecordingMutator : IStockMutator
+    {
+        public List<IReadOnlyList<StockDelta>> Calls { get; } = new();
+
+        public Task<IReadOnlyList<StockLedger>> ApplyAsync(int warehouseId, string sourceDocType, int sourceDocId, DateTime now,
+            IReadOnlyList<StockDelta> deltas, CancellationToken ct = default)
+        {
+            Calls.Add(deltas);
+            IReadOnlyList<StockLedger> refs = deltas.Select(d => new StockLedger
+            {
+                ItemId = d.ItemId, WarehouseId = warehouseId, QtyBase = Math.Abs(d.QtyDelta), UnitCost = 10m, Value = Math.Abs(d.QtyDelta) * 10m,
+                Direction = d.QtyDelta < 0 ? Direction.Out : Direction.In, SourceDocType = sourceDocType, SourceDocId = sourceDocId, CreatedAt = now
+            }).ToList();
+            return Task.FromResult(refs);
+        }
+    }
+
+    /// <summary>10 units on hand worth 100.00 — 10.00 each, which prices requests for the threshold.</summary>
+    private sealed class FixedValuation : IFifoCostingService
+    {
+        public Task<StockValuationDto> GetValuationAsync(int itemId, int warehouseId, CancellationToken ct = default)
+            => Task.FromResult(new StockValuationDto(itemId, warehouseId, [], 10m, 100m, "LKR", "FIFO"));
+        public Task<StockLayer> CreateInboundLayerAsync(int itemId, int warehouseId, int? batchId, int? serialId, int? grnLineId,
+            decimal qtyBase, decimal unitCost, DateTime receiptDate, CancellationToken ct = default) => throw new NotSupportedException();
+        public Task<IReadOnlyList<ConsumedSegment>> ConsumeAsync(int itemId, int warehouseId, int? batchId, decimal qtyBase, CancellationToken ct = default,
+            bool allowShortfall = false, IReadOnlyCollection<int>? serialIds = null) => throw new NotSupportedException();
+        public Task<IReadOnlyList<BatchAllocation>> SuggestBatchesAsync(int itemId, int warehouseId, decimal qtyBase, CancellationToken ct = default)
+            => throw new NotSupportedException();
+        public Task<StockLedger> PostLedgerAsync(int itemId, int warehouseId, int? binId, int? batchId, int? serialId, int userId,
+            Direction direction, decimal qtyBase, decimal unitCost, decimal runningBalance, string sourceDocType, int sourceDocId,
+            DateTime createdAt, CancellationToken ct = default, decimal? valueOverride = null) => throw new NotSupportedException();
+        public Task<decimal> GetOnHandAsync(int itemId, int warehouseId, CancellationToken ct = default) => Task.FromResult(10m);
+    }
+
+    private sealed class RecordingNotifications : INotificationService
+    {
+        public List<(IReadOnlyList<int> UserIds, string ModuleKey, string Message)> Targeted { get; } = new();
+
+        public Task RaiseAsync(string moduleKey, string title, string message, string? relatedEntityType = null, int? relatedEntityId = null,
+            CancellationToken ct = default) => Task.CompletedTask;
+
+        public Task NotifyUsersAsync(IEnumerable<int> userIds, string moduleKey, string title, string message,
+            string? relatedEntityType = null, int? relatedEntityId = null, CancellationToken ct = default)
+        {
+            Targeted.Add((userIds.ToList(), moduleKey, message));
+            return Task.CompletedTask;
+        }
+
+        public Task<NotificationFeedDto> GetFeedAsync(int userId, int take = 20, CancellationToken ct = default) => throw new NotSupportedException();
+        public Task MarkAllReadAsync(int userId, CancellationToken ct = default) => throw new NotSupportedException();
+    }
+}
diff --git a/Backend/ERPCore.Tests/ItemTrackingTests.cs b/Backend/ERPCore.Tests/ItemTrackingTests.cs
new file mode 100644
index 0000000..3b83fd2
--- /dev/null
+++ b/Backend/ERPCore.Tests/ItemTrackingTests.cs
@@ -0,0 +1,366 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.Persistence;
+using ERPCore.Repositories;
+using ERPCore.Services;
+using ERPCore.Services.Stock;
+using ERPCore.System.Errors;
+using ERPCore.Tests.TestSupport;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace ERPCore.Tests;
+
+/// <summary>
+/// Serial/batch rules from docs/ITEM_TRACKING_PLAN.md that live outside the MariaDB-only FIFO
+/// SQL: the sales-line check (<see cref="SalesDomainService.ValidateLineTrackingAsync"/>) and the
+/// shared stock-document rules (<see cref="SerialTrackingService"/>).
+/// </summary>
+public class ItemTrackingTests
+{
+    private static readonly InMemoryDatabaseRoot Root = new();
+
+    private const int Wh1 = 1;
+    private const int Wh2 = 2;
+    private const int SerialItemId = 10;
+    private const int BatchItemId = 20;
+    private const int PlainItemId = 30;
+
+    // --- sales line validation --------------------------------------------------------------
+
+    [Fact]
+    public async Task SalesLine_SerialItem_RequiresOneSerialPerUnit()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 2, null, new[] { 1 }, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.TrackingRequired, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_SerialItem_WithoutSerials_IsRejected_WhenNoPreTrackingStockIsLeft()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, null, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.TrackingRequired, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_SerialItem_WithoutSerials_IsAllowed_FromPreTrackingStock()
+    {
+        await using var db = await SeedAsync();
+        // D6: stock received before serial capture — a layer with no serial.
+        db.StockLayers.Add(new StockLayer { ItemId = SerialItemId, WarehouseId = Wh1, QtyReceived = 3, QtyRemaining = 3, UnitCost = 10, ReceiptDate = DateTime.UtcNow });
+        await db.SaveChangesAsync();
+        var sales = CreateSalesDomain(db);
+
+        var serials = await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 2, null, null, new HashSet<int>());
+
+        Assert.Empty(serials);
+    }
+
+    [Fact]
+    public async Task SalesLine_Serial_AtAnotherWarehouse_IsNotAvailable()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        // Serial 3 is in stock at warehouse 2.
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 3 }, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.SerialNotAvailable, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_SoldSerial_IsNotAvailable()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 4 }, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.SerialNotAvailable, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_SameSerialOnTwoLines_IsADuplicate()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+        var documentSerials = new HashSet<int>();
+
+        await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 1 }, documentSerials);
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 1 }, documentSerials));
+
+        Assert.Equal(ErrorCodes.SerialDuplicate, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_ValidSerials_AreReturned()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var serials = await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 2, null, new[] { 1, 2 }, new HashSet<int>());
+
+        Assert.Equal(new[] { 1, 2 }, serials.Select(s => s.SerialId).OrderBy(i => i));
+    }
+
+    [Fact]
+    public async Task SalesLine_UntrackedItem_RejectsSerials()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(PlainItemId, Wh1, 1, null, new[] { 1 }, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.Validation, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_ExpiredBatch_IsBlocked()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(BatchItemId, Wh1, 1, 101, null, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.ExpiredBatchBlocked, ex.Code);
+    }
+
+    [Fact]
+    public async Task SalesLine_BatchOfAnotherItem_IsRejected()
+    {
+        await using var db = await SeedAsync();
+        var sales = CreateSalesDomain(db);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(PlainItemId, Wh1, 1, 100, null, new HashSet<int>()));
+
+        Assert.Equal(ErrorCodes.Validation, ex.Code);
+    }
+
+    // --- stock documents (transfers / adjustments / purchase returns) ------------------------
+
+    [Fact]
+    public async Task Outbound_DamagedSerial_OnlyWhenAllowed()
+    {
+        await using var db = await SeedAsync();
+        var tracking = CreateSerialTracking(db);
+        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
+
+        // Serial 5 is Damaged at warehouse 1: a transfer (InStock only) refuses it...
+        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.ResolveOutboundAsync(
+            item, Wh1, 1, new[] { 5 }, new HashSet<int>(), new[] { SerialStatus.InStock }));
+        Assert.Equal(ErrorCodes.SerialNotAvailable, ex.Code);
+
+        // ...a write-off or purchase return (InStock or Damaged) takes it.
+        var serials = await tracking.ResolveOutboundAsync(
+            item, Wh1, 1, new[] { 5 }, new HashSet<int>(), new[] { SerialStatus.InStock, SerialStatus.Damaged });
+        Assert.Single(serials);
+    }
+
+    [Fact]
+    public async Task Inbound_SerialAlreadyInStock_IsADuplicate()
+    {
+        await using var db = await SeedAsync();
+        var tracking = CreateSerialTracking(db);
+        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.ResolveInboundAsync(
+            item, Wh1, 1, new[] { "SN-1" }, new HashSet<string>()));
+
+        Assert.Equal(ErrorCodes.SerialDuplicate, ex.Code);
+    }
+
+    [Fact]
+    public async Task Inbound_FractionalQty_IsRejected_ForSerialItems()
+    {
+        await using var db = await SeedAsync();
+        var tracking = CreateSerialTracking(db);
+        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.ResolveInboundAsync(
+            item, Wh1, 1.5m, new[] { "SN-NEW" }, new HashSet<string>()));
+
+        Assert.Equal(ErrorCodes.Validation, ex.Code);
+    }
+
+    [Fact]
+    public async Task Inbound_NewAndSoldSerials_AreCreatedOrBroughtBack()
+    {
+        await using var db = await SeedAsync();
+        var tracking = CreateSerialTracking(db);
+        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
+
+        // SN-4 is Sold (out of stock) — it comes back; SN-NEW does not exist — it is created.
+        var serials = await tracking.ResolveInboundAsync(item, Wh1, 2, new[] { "SN-4", "SN-NEW" }, new HashSet<string>());
+        await tracking.MoveAsync(serials, SerialStatus.InStock, Wh1, null, "ADJ", 1, DateTime.UtcNow);
+        await db.SaveChangesAsync();
+
+        var all = await db.Serials.Where(s => s.ItemId == SerialItemId && (s.SerialNo == "SN-4" || s.SerialNo == "SN-NEW")).ToListAsync();
+        Assert.All(all, s => Assert.Equal(SerialStatus.InStock, s.Status));
+        Assert.All(all, s => Assert.Equal(Wh1, s.WarehouseId));
+        Assert.Equal(2, await db.SerialMovements.CountAsync(m => m.SourceDocType == "ADJ"));
+    }
+
+    [Fact]
+    public async Task Move_RecordsHistory_WithPreviousWarehouse()
+    {
+        await using var db = await SeedAsync();
+        var tracking = CreateSerialTracking(db);
+        var serial = await db.Serials.FirstAsync(s => s.SerialId == 1);
+
+        await tracking.MoveAsync(new[] { serial }, SerialStatus.InTransit, null, null, "TRF", 7, DateTime.UtcNow);
+        await db.SaveChangesAsync();
+
+        var movement = await db.SerialMovements.SingleAsync(m => m.SerialId == 1);
+        Assert.Equal(SerialStatus.InTransit, movement.Status);
+        Assert.Equal(Wh1, movement.FromWarehouseId);
+        Assert.Null(movement.WarehouseId);
+        Assert.Null(serial.WarehouseId);
+    }
+
+    // --- auto-generated serial numbers -------------------------------------------------------
+
+    [Fact]
+    public async Task NextNumbers_ContinueAfterHighestUsed_AndSkipDraftGrnNumbers()
+    {
+        await using var db = await SeedAsync();
+        db.Serials.Add(new Serial { SerialId = 50, ItemId = SerialItemId, SerialNo = "PH-0041", Status = SerialStatus.Sold });
+        // A draft GRN line already holds PH-0042 (not yet a Serial).
+        db.GrnLines.Add(new GrnLine { GrnLineId = 900, GrnId = 1, ItemId = SerialItemId, Qty = 1,
+            Serials = { new GrnLineSerial { SerialNo = "PH-0042" } } });
+        await db.SaveChangesAsync();
+        var tracking = new ItemTrackingService(db, null!);
+
+        var next = await tracking.NextSerialNumbersAsync(SerialItemId, "PH-", 3);
+
+        Assert.Equal(new[] { "PH-0043", "PH-0044", "PH-0045" }, next);
+    }
+
+    [Fact]
+    public async Task NextNumbers_StartAtOne_ForANewPrefix_AndIgnoreOtherItems()
+    {
+        await using var db = await SeedAsync();
+        db.Serials.Add(new Serial { SerialId = 51, ItemId = PlainItemId, SerialNo = "NEW-0099", Status = SerialStatus.InStock });
+        await db.SaveChangesAsync();
+        var tracking = new ItemTrackingService(db, null!);
+
+        var next = await tracking.NextSerialNumbersAsync(SerialItemId, "NEW-", 2);
+
+        Assert.Equal(new[] { "NEW-0001", "NEW-0002" }, next);
+    }
+
+    [Fact]
+    public async Task NextNumbers_RejectsTooMany()
+    {
+        await using var db = await SeedAsync();
+        var tracking = new ItemTrackingService(db, null!);
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() => tracking.NextSerialNumbersAsync(SerialItemId, "X-", 5000));
+
+        Assert.Equal(ErrorCodes.Validation, ex.Code);
+    }
+
+    // --- fixtures ---------------------------------------------------------------------------
+
+    private static async Task<ErpDbContext> SeedAsync()
+    {
+        var db = CreateContext();
+        db.Items.AddRange(
+            new Item { ItemId = SerialItemId, Sku = "SER-1", Name = "Phone", CategoryId = 1, BaseUomId = 1, StockNature = StockNature.Stocked, TrackingMode = TrackingMode.Serial },
+            new Item { ItemId = BatchItemId, Sku = "BAT-1", Name = "Milk", CategoryId = 1, BaseUomId = 1, StockNature = StockNature.Stocked, TrackingMode = TrackingMode.Batch },
+            new Item { ItemId = PlainItemId, Sku = "PLN-1", Name = "Bolt", CategoryId = 1, BaseUomId = 1, StockNature = StockNature.Stocked, TrackingMode = TrackingMode.None });
+        db.Batches.AddRange(
+            new Batch { BatchId = 100, ItemId = BatchItemId, BatchNo = "B-OK", ExpiryDate = DateOnly.FromDateTime(DateTime.UtcNow).AddDays(30) },
+            new Batch { BatchId = 101, ItemId = BatchItemId, BatchNo = "B-EXP", ExpiryDate = DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-1) });
+        db.Serials.AddRange(
+            new Serial { SerialId = 1, ItemId = SerialItemId, SerialNo = "SN-1", Status = SerialStatus.InStock, WarehouseId = Wh1 },
+            new Serial { SerialId = 2, ItemId = SerialItemId, SerialNo = "SN-2", Status = SerialStatus.InStock, WarehouseId = Wh1 },
+            new Serial { SerialId = 3, ItemId = SerialItemId, SerialNo = "SN-3", Status = SerialStatus.InStock, WarehouseId = Wh2 },
+            new Serial { SerialId = 4, ItemId = SerialItemId, SerialNo = "SN-4", Status = SerialStatus.Sold, WarehouseId = null },
+            new Serial { SerialId = 5, ItemId = SerialItemId, SerialNo = "SN-5", Status = SerialStatus.Damaged, WarehouseId = Wh1 });
+        await db.SaveChangesAsync();
+        return db;
+    }
+
+    private static ErpDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ErpDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
+            .Options;
+        var currentUser = new TestCurrentUser();
+        return new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
+    }
+
+    // Pricing is never touched by the tracking check, so it is not wired.
+    private static SalesDomainService CreateSalesDomain(ErpDbContext db) => new(
+        new Repository<Customer>(db), new Repository<Warehouse>(db), new Repository<User>(db),
+        new Repository<Item>(db), new Repository<TaxRate>(db), null!, new Repository<SalesConfig>(db),
+        new Repository<Batch>(db), new Repository<Serial>(db), new Repository<StockLayer>(db),
+        CreateSerialTracking(db));
+
+    private static SerialTrackingService CreateSerialTracking(ErpDbContext db) => new(
+        new Repository<Serial>(db), new Repository<SerialMovement>(db), new Repository<StockLayer>(db),
+        new Repository<ProductConfig>(db), new TestCurrentUser());
+
+    private static async Task SwitchSerialNumbersAsync(ErpDbContext db, bool enabled)
+    {
+        db.ProductConfig.Add(new ProductConfig { ConfigId = ProductConfig.SingletonId, SerialNumbersEnabled = enabled });
+        await db.SaveChangesAsync();
+    }
+
+    // --- Product Configuration "Serial numbers" switch ---------------------------------------
+
+    [Fact]
+    public async Task SwitchOff_SerialItemSells_WithoutSerials()
+    {
+        await using var db = await SeedAsync();
+        await SwitchSerialNumbersAsync(db, enabled: false);
+        var sales = CreateSalesDomain(db);
+
+        // No pre-tracking stock exists, yet nothing is asked: the item is plain stock now.
+        var serials = await sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 5, null, null, new HashSet<int>());
+
+        Assert.Empty(serials);
+    }
+
+    [Fact]
+    public async Task SwitchOff_SerialsSent_AreRefused()
+    {
+        await using var db = await SeedAsync();
+        await SwitchSerialNumbersAsync(db, enabled: false);
+        var sales = CreateSalesDomain(db);
+        var tracking = CreateSerialTracking(db);
+        var item = await db.Items.FirstAsync(i => i.ItemId == SerialItemId);
+
+        var sale = await Assert.ThrowsAsync<DomainException>(() =>
+            sales.ValidateLineTrackingAsync(SerialItemId, Wh1, 1, null, new[] { 1 }, new HashSet<int>()));
+        var adjustment = await Assert.ThrowsAsync<DomainException>(() =>
+            tracking.ResolveInboundAsync(item, Wh1, 1, new[] { "SN-X" }, new HashSet<string>()));
+
+        Assert.Equal(ErrorCodes.ConfigDisabled, sale.Code);
+        Assert.Equal(ErrorCodes.ConfigDisabled, adjustment.Code);
+    }
+
+    [Fact]
+    public async Task SwitchOn_IsTheDefault_WhenConfigRowIsMissing()
+    {
+        await using var db = await SeedAsync();
+        Assert.True(await CreateSerialTracking(db).IsEnabledAsync());
+    }
+}
diff --git a/Backend/ERPCore.Tests/LowStockAlertServiceTests.cs b/Backend/ERPCore.Tests/LowStockAlertServiceTests.cs
new file mode 100644
index 0000000..9360a77
--- /dev/null
+++ b/Backend/ERPCore.Tests/LowStockAlertServiceTests.cs
@@ -0,0 +1,116 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Notifications;
+using ERPCore.Dtos.Stock;
+using ERPCore.Infra.Persistence;
+using ERPCore.Repositories;
+using ERPCore.Services.Interfaces;
+using ERPCore.Services.Stock;
+using ERPCore.Tests.TestSupport;
+
+namespace ERPCore.Tests;
+
+/// <summary>Low-stock / reorder alerts raised after stock issues.</summary>
+public class LowStockAlertServiceTests
+{
+    private const int ItemId = 1, WarehouseId = 1;
+
+    [Theory]
+    [InlineData(12, 4, 8, true)]    // 12 → 8 crosses the alert level of 10
+    [InlineData(12, 2, 10, true)]   // landing exactly on the level counts
+    [InlineData(20, 5, 15, false)]  // still above the level
+    [InlineData(9, 3, 6, false)]    // was already low — no repeat alert on every sale
+    public async Task Alerts_OnlyWhenAnIssueCrossesTheReorderPoint(decimal before, decimal issued, decimal after, bool alerts)
+    {
+        Assert.Equal(before - issued, after);
+        await using var db = Seed();
+        var tracker = new LowStockTracker();
+        tracker.Track(ItemId, WarehouseId, issued);
+        var notifications = new RecordingNotifications();
+
+        await Service(db, tracker, after, notifications).CheckAsync();
+
+        if (!alerts)
+        {
+            Assert.Empty(notifications.Raised);
+            return;
+        }
+        var raised = Assert.Single(notifications.Raised);
+        Assert.Equal(LowStockAlertService.ModuleKey, raised.ModuleKey);
+        Assert.Contains("SKU-1", raised.Message);
+        Assert.Contains($"down to {after:0.####} pcs at WH-1", raised.Message);
+        Assert.Contains("Suggested reorder: 50 pcs", raised.Message);
+    }
+
+    [Fact]
+    public async Task ItemsWithoutARule_OrUntouched_AreIgnored()
+    {
+        await using var db = Seed();
+        var tracker = new LowStockTracker();
+        tracker.Track(itemId: 99, WarehouseId, 100);     // no rule for this item
+        var notifications = new RecordingNotifications();
+
+        await Service(db, tracker, available: 0, notifications).CheckAsync();
+        await Service(db, new LowStockTracker(), available: 0, notifications).CheckAsync();  // nothing issued
+
+        Assert.Empty(notifications.Raised);
+    }
+
+    [Fact]
+    public async Task Tracker_SumsIssuesWithinARequest_AndEmptiesWhenDrained()
+    {
+        var tracker = new LowStockTracker();
+        tracker.Track(ItemId, WarehouseId, 3);
+        tracker.Track(ItemId, WarehouseId, 4);
+        tracker.Track(ItemId, WarehouseId, 0);
+
+        Assert.Equal(7m, tracker.Drain()[(ItemId, WarehouseId)]);
+        Assert.Empty(tracker.Drain());
+    }
+
+    private static LowStockAlertService Service(ErpDbContext db, LowStockTracker tracker, decimal available, INotificationService notifications)
+        => new(tracker, new Repository<ItemReorder>(db), new FixedStock(available), notifications);
+
+    private static ErpDbContext Seed()
+    {
+        var db = BankDepositTestSupport.CreateContext();   // users, branches, warehouses WH-1 / WH-2
+        db.Uoms.Add(new Uom { UomId = 1, Name = "pcs" });
+        db.Items.Add(new Item { ItemId = ItemId, Sku = "SKU-1", Name = "Cola 500ml", BaseUomId = 1, CategoryId = 1 });
+        db.ItemReorders.Add(new ItemReorder { ReorderId = 1, ItemId = ItemId, WarehouseId = WarehouseId, ReorderPoint = 10, ReorderQty = 50 });
+        db.SaveChanges();
+        return db;
+    }
+
+    private sealed class FixedStock(decimal available) : IStockService
+    {
+        public Task<StockOnHandDto> GetOnHandAsync(int itemId, int warehouseId, CancellationToken ct = default)
+            => Task.FromResult(new StockOnHandDto(itemId, warehouseId, available, available, 0, 0, 0, DateTime.UtcNow));
+        public Task<PagedResponse<StockOnHandDto>> GetOnHandListAsync(int? itemId, int? warehouseId, int? branchId, PageQuery query, CancellationToken ct = default)
+            => throw new NotSupportedException();
+        public Task<IReadOnlyDictionary<int, decimal>> GetAvailableByItemAsync(int warehouseId, CancellationToken ct = default)
+            => throw new NotSupportedException();
+        public Task<PagedResponse<StockLedgerRowDto>> GetLedgerAsync(int? itemId, int? warehouseId, int? branchId, DateOnly? from, DateOnly? to,
+            string? sourceDocType, int? sourceDocId, PageQuery query, CancellationToken ct = default) => throw new NotSupportedException();
+        public Task<StockValuationDto> GetValuationAsync(int itemId, int warehouseId, CancellationToken ct = default)
+            => throw new NotSupportedException();
+    }
+
+    private sealed class RecordingNotifications : INotificationService
+    {
+        public List<(string ModuleKey, string Title, string Message)> Raised { get; } = new();
+
+        public Task RaiseAsync(string moduleKey, string title, string message, string? relatedEntityType = null,
+            int? relatedEntityId = null, CancellationToken ct = default)
+        {
+            Raised.Add((moduleKey, title, message));
+            return Task.CompletedTask;
+        }
+
+        public Task NotifyUsersAsync(IEnumerable<int> userIds, string moduleKey, string title, string message,
+            string? relatedEntityType = null, int? relatedEntityId = null, CancellationToken ct = default) => throw new NotSupportedException();
+
+        public Task<NotificationFeedDto> GetFeedAsync(int userId, int take = 20, CancellationToken ct = default) => throw new NotSupportedException();
+        public Task MarkAllReadAsync(int userId, CancellationToken ct = default) => throw new NotSupportedException();
+    }
+}
diff --git a/Backend/ERPCore.Tests/TestSupport/BankDepositTestSupport.cs b/Backend/ERPCore.Tests/TestSupport/BankDepositTestSupport.cs
new file mode 100644
index 0000000..e56526c
--- /dev/null
+++ b/Backend/ERPCore.Tests/TestSupport/BankDepositTestSupport.cs
@@ -0,0 +1,172 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Config;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.Gl;
+using ERPCore.Infra.Persistence;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories;
+using ERPCore.Services;
+using ERPCore.Services.Gl;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.Extensions.Configuration;
+
+namespace ERPCore.Tests.TestSupport;
+
+/// <summary>Records every journal it is asked to post; can be told to reject them instead.</summary>
+internal sealed class FakeGeneralLedger : IGeneralLedgerService
+{
+    public const long CashAccountId = 1, BankAccountId = 2, OtherBankAccountId = 3;
+
+    public List<GlJournalEntryRequest> Posted { get; } = new();
+    public bool Reject { get; set; }
+
+    public IReadOnlyList<GlBankAccount> Accounts { get; init; } =
+    [
+        new("Cash", CashAccountId, "Main Till", null, "Petty", null, 101, "1000-01", "LKR"),
+        new("Bank", BankAccountId, "BOC Current", "Bank of Ceylon", null, "0001234567", 102, "1010-01", "LKR"),
+        new("Bank", OtherBankAccountId, "HNB Savings", "Hatton National Bank", null, "9876543210", 103, "1010-02", "LKR")
+    ];
+
+    public Task<GeneralLedgerResponse> ForwardAsync(HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
+        => throw new NotSupportedException();
+
+    public Task<GlJournalEntryResult> PostJournalEntryAsync(GlJournalEntryRequest request, CancellationToken ct)
+    {
+        if (Reject) throw new DomainException(ErrorCodes.Validation, "GL rejected the entry.", 502);
+        Posted.Add(request);
+        return Task.FromResult(new GlJournalEntryResult($"JE-{Posted.Count}", true));
+    }
+
+    public Task<GlPeriod> GetPeriodByDateAsync(DateOnly date, CancellationToken ct) => Task.FromResult(new GlPeriod(1, 1));
+
+    public Task<IReadOnlyList<GlBankAccount>> ListBankAccountsAsync(CancellationToken ct) => Task.FromResult(Accounts);
+
+    /// <summary>Not implemented on purpose — nothing here picks a GL account by code; see
+    /// <see cref="StubGeneralLedgerService"/> for the fake that does.</summary>
+    public Task<IReadOnlyList<GlAccount>> ListAccountsAsync(CancellationToken ct) => throw new NotSupportedException();
+}
+
+/// <summary>The in-memory provider has no transactions: run the work, then save — what the real one commits.</summary>
+internal sealed class PassThroughUnitOfWork(ErpDbContext db) : IUnitOfWork
+{
+    public Task<int> SaveChangesAsync(CancellationToken ct = default) => db.SaveChangesAsync(ct);
+
+    public async Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken ct = default)
+    {
+        await action(ct);
+        await db.SaveChangesAsync(ct);
+    }
+
+    public async Task<T> ExecuteInTransactionAsync<T>(Func<CancellationToken, Task<T>> action, CancellationToken ct = default)
+    {
+        var result = await action(ct);
+        await db.SaveChangesAsync(ct);
+        return result;
+    }
+}
+
+internal sealed class FakeNumberSequence : INumberSequenceService
+{
+    private int _next;
+    public Task<string> NextAsync(string docType, int branchId, CancellationToken ct = default) => Task.FromResult($"{docType}-{++_next:00000}");
+    public Task<string> NextAsync(string docType, CancellationToken ct = default) => Task.FromResult($"{docType}-{++_next:00000}");
+}
+
+/// <summary>Branching on: the requested branch is used as-is.</summary>
+internal sealed class FakeBranchConfig : IBranchConfigService
+{
+    public Task<ETagged<BranchConfigDto>> GetAsync(CancellationToken ct = default) => throw new NotSupportedException();
+    public Task<ETagged<BranchConfigDto>> UpdateAsync(UpdateBranchConfigRequest request, uint expectedRowVersion, CancellationToken ct = default)
+        => throw new NotSupportedException();
+    public Task<bool> IsBranchingEnabledAsync(CancellationToken ct = default) => Task.FromResult(true);
+    public Task<int> ResolveBranchIdAsync(int requestedBranchId, CancellationToken ct = default)
+        => requestedBranchId > 0 ? Task.FromResult(requestedBranchId) : throw new DomainException(ErrorCodes.Validation, "Branch is required.", 422);
+    public Task<bool> IsWarehouseBranchingEnabledAsync(CancellationToken ct = default) => Task.FromResult(true);
+    public Task<int> ResolveWarehouseBranchIdAsync(int requestedBranchId, CancellationToken ct = default) => Task.FromResult(requestedBranchId);
+    public Task<int> ResolveDefaultBranchIdAsync(CancellationToken ct = default) => Task.FromResult(1);
+}
+
+/// <summary>Seeds and services for the cash-in-hand / bank-deposit tests. Two branches, one warehouse each.</summary>
+internal static class BankDepositTestSupport
+{
+    private static readonly InMemoryDatabaseRoot Root = new();
+
+    public const int Branch1 = 1, Branch2 = 2;
+    public const int Warehouse1 = 1, Warehouse2 = 2;
+
+    public static BusinessDayClock Clock { get; } = new(Config());
+
+    public static IConfiguration Config(DateOnly? trackingStart = null) => new ConfigurationBuilder()
+        .AddInMemoryCollection(new Dictionary<string, string?>
+        {
+            ["DayEndReport:TimeZone"] = "Asia/Colombo",
+            ["BankDeposit:DefaultCashAccountCode"] = "1000-01",
+            ["BankDeposit:CashTrackingStartDate"] = trackingStart?.ToString("yyyy-MM-dd")
+        })
+        .Build();
+
+    /// <summary>Midday on a local business day, as the UTC instant documents are stamped with.</summary>
+    public static DateTime At(DateOnly day) => Clock.ToUtc(day).AddHours(6);
+
+    public static ErpDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ErpDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString("N"), Root)
+            .Options;
+        var currentUser = new TestCurrentUser();
+        var db = new ErpDbContext(options, currentUser, new CurrentBranchContext(currentUser));
+
+        db.Users.Add(new User { UserId = User.SystemUserId, Username = "system", DisplayName = "System" });
+        db.Branches.AddRange(
+            new Branch { BranchId = Branch1, Code = "BR-001", Name = "Colombo" },
+            new Branch { BranchId = Branch2, Code = "BR-002", Name = "Kandy" });
+        db.Warehouses.AddRange(
+            new Warehouse { WarehouseId = Warehouse1, Code = "WH-1", Name = "Colombo Store", BranchId = Branch1 },
+            new Warehouse { WarehouseId = Warehouse2, Code = "WH-2", Name = "Kandy Store", BranchId = Branch2 });
+        db.SaveChanges();
+        return db;
+    }
+
+    private static int _id;
+
+    public static SalesSlip CashSlip(DateOnly day, decimal cash, decimal card = 0m, int warehouseId = Warehouse1)
+    {
+        var id = Interlocked.Increment(ref _id);
+        return new SalesSlip
+        {
+            SalesSlipId = id, SlipNo = $"SL-{id}", SlipDate = At(day), Status = SalesSlipStatus.Posted, WarehouseId = warehouseId,
+            GrandTotal = cash + card, PaidAmount = cash + card, CashAmount = cash, CardAmount = card
+        };
+    }
+
+    public static CashInHandService CashService(ErpDbContext db, DateOnly? trackingStart)
+        => new(new Repository<SalesSlip>(db), new Repository<BundleSale>(db), new Repository<SalesInvoicePayment>(db),
+            new Repository<ExpensePayment>(db), new Repository<BankDeposit>(db),
+            new CurrentBranchContext(new TestCurrentUser()), Clock, Config(trackingStart));
+
+    public static BankDepositService DepositService(ErpDbContext db, DateOnly? trackingStart, FakeGeneralLedger gl)
+    {
+        var currentUser = new TestCurrentUser();
+        return new BankDepositService(
+            new Repository<BankDeposit>(db), new Repository<Branch>(db), CashService(db, trackingStart), gl,
+            currentUser, new CurrentBranchContext(currentUser), new FakeNumberSequence(), new FakeBranchConfig(),
+            new PassThroughUnitOfWork(db), db, Clock);
+    }
+
+    public static BankDeposit Deposit(DateOnly businessDate, decimal amount, int branchId = Branch1,
+        BankDepositStatus status = BankDepositStatus.Posted)
+    {
+        var id = Interlocked.Increment(ref _id);
+        return new BankDeposit
+        {
+            BankDepositId = id, DocNo = $"BD-{id}", BranchId = branchId, BusinessDate = businessDate, DepositDate = businessDate,
+            Amount = amount, Status = status, FromCashAccountCode = "1000-01", FromCashAccountName = "Main Till",
+            ToBankAccountCode = "1010-01", ToBankAccountName = "BOC Current", CreatedBy = User.SystemUserId
+        };
+    }
+}
diff --git a/Backend/ERPCore/Controllers/ApprovalsController.cs b/Backend/ERPCore/Controllers/ApprovalsController.cs
new file mode 100644
index 0000000..f3d691a
--- /dev/null
+++ b/Backend/ERPCore/Controllers/ApprovalsController.cs
@@ -0,0 +1,43 @@
+using Microsoft.AspNetCore.Authorization;
+using ERPCore.Dtos.Approvals;
+using ERPCore.Infra.Auth;
+using ERPCore.Services;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Approvals inbox and settings (docs/DUAL_APPROVAL_PLAN.md §7, §10). The inbox is open to every
+/// signed-in user — it only lists what they may approve and their own requests. Reading the
+/// settings is open too (screens need to know whether prices are locked); changing them needs
+/// <c>settings.approvals</c>.
+/// </summary>
+[Route("api/v1/approvals")]
+public sealed class ApprovalsController : ApiControllerBase
+{
+    private readonly ApprovalInboxService _inbox;
+    private readonly IApprovalService _approvals;
+
+    public ApprovalsController(ApprovalInboxService inbox, IApprovalService approvals)
+    {
+        _inbox = inbox;
+        _approvals = approvals;
+    }
+
+    [HttpGet("pending")]
+    [ProducesResponseType(typeof(PendingApprovalsDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PendingApprovalsDto>> Pending(CancellationToken ct)
+        => Ok(await _inbox.PendingAsync(ct));
+
+    [HttpGet("config")]
+    [ProducesResponseType(typeof(ApprovalConfigDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApprovalConfigDto>> GetConfig(CancellationToken ct)
+        => Ok(await _approvals.GetConfigAsync(ct));
+
+    [HttpPut("config")]
+    [Authorize(Policy = NavPolicies.Prefix + "settings.approvals")]
+    [ProducesResponseType(typeof(ApprovalConfigDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApprovalConfigDto>> UpdateConfig([FromBody] UpdateApprovalConfigRequest request, CancellationToken ct)
+        => Ok(await _approvals.UpdateConfigAsync(request, ct));
+}
diff --git a/Backend/ERPCore/Controllers/BankDepositsController.cs b/Backend/ERPCore/Controllers/BankDepositsController.cs
new file mode 100644
index 0000000..8c25e40
--- /dev/null
+++ b/Backend/ERPCore/Controllers/BankDepositsController.cs
@@ -0,0 +1,78 @@
+using Microsoft.AspNetCore.Authorization;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Accounts;
+using ERPCore.Dtos.Common;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Till cash deposited to the bank, and the cash in hand behind it (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.3).
+/// Recording needs the Create action on <c>accounts.bank-deposits</c>; cancelling needs Delete.
+/// </summary>
+[Route("api/v1/bank-deposits")]
+[Authorize(Policy = NavPolicies.Prefix + "accounts.bank-deposits")]
+public sealed class BankDepositsController : ApiControllerBase
+{
+    private readonly IBankDepositService _deposits;
+    private readonly ICashInHandService _cash;
+
+    public BankDepositsController(IBankDepositService deposits, ICashInHandService cash)
+    {
+        _deposits = deposits;
+        _cash = cash;
+    }
+
+    /// <summary>Deposits filtered by business date range, branch, bank account and status, plus their total.</summary>
+    [HttpGet]
+    [ProducesResponseType(typeof(BankDepositListDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<BankDepositListDto>> List(
+        [FromQuery] PageQuery query, [FromQuery] DateOnly? from, [FromQuery] DateOnly? to, [FromQuery] int? branchId,
+        [FromQuery] long? bankAccountId, [FromQuery] BankDepositStatus? status, CancellationToken ct)
+        => Ok(await _deposits.ListAsync(query, new BankDepositListFilter(from, to, branchId, bankAccountId, status), ct));
+
+    [HttpGet("{bankDepositId:int}")]
+    [ProducesResponseType(typeof(BankDepositDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<BankDepositDto>> GetById(int bankDepositId, CancellationToken ct)
+    {
+        var result = await _deposits.GetAsync(bankDepositId, ct);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    /// <summary>One business day's cash position (defaults to today) and how much of it can still be deposited.</summary>
+    [HttpGet("cash-in-hand")]
+    [ProducesResponseType(typeof(CashInHandDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<CashInHandDto>> CashInHand([FromQuery] DateOnly? date, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _cash.GetPositionAsync(date, branchId, ct));
+
+    /// <summary>Day-wise cash position for <c>from</c>..<c>to</c> inclusive (at most 92 days).</summary>
+    [HttpGet("cash-in-hand/daily")]
+    [ProducesResponseType(typeof(CashInHandDailyDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<CashInHandDailyDto>> CashInHandDaily(
+        [FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _cash.GetDailyAsync(from, to, branchId, ct));
+
+    /// <summary>Record a deposit; posts GL (Debit bank / Credit cash). Rejected above the cash in hand.</summary>
+    [HttpPost]
+    [Authorize(Policy = NavPolicies.Prefix + "accounts.bank-deposits" + NavPolicies.ActionSeparator + NavPolicies.CreateAction)]
+    [ProducesResponseType(typeof(BankDepositDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<BankDepositDto>> Create([FromBody] CreateBankDepositRequest request, CancellationToken ct)
+    {
+        var result = await _deposits.CreateAsync(request, ct);
+        return Created($"/api/v1/bank-deposits/{result.BankDepositId}", result);
+    }
+
+    /// <summary>Cancel a Posted deposit; posts the reversing GL entry and puts the cash back in hand.</summary>
+    [HttpPost("{bankDepositId:int}/cancel")]
+    [Authorize(Policy = NavPolicies.Prefix + "accounts.bank-deposits" + NavPolicies.ActionSeparator + NavPolicies.DeleteAction)]
+    [ProducesResponseType(typeof(BankDepositDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<BankDepositDto>> Cancel(int bankDepositId, [FromBody] CancelBankDepositRequest request, CancellationToken ct)
+        => Ok(await _deposits.CancelAsync(bankDepositId, request, ct));
+}
diff --git a/Backend/ERPCore/Controllers/DayEndReportController.cs b/Backend/ERPCore/Controllers/DayEndReportController.cs
new file mode 100644
index 0000000..590a239
--- /dev/null
+++ b/Backend/ERPCore/Controllers/DayEndReportController.cs
@@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.Authorization;
+using ERPCore.Dtos.Reports;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Day-End Sales Report — a day's sales, payments by method, expenses and income, and the
+/// same day-wise over a range for the income chart/PDF (docs/DAY_END_SALES_REPORT_PLAN.md §4).</summary>
+[Route("api/v1/day-end-report")]
+[Authorize(Policy = NavPolicies.Prefix + "sales.day-end-report")]
+public sealed class DayEndReportController : ApiControllerBase
+{
+    private readonly IDayEndReportService _reports;
+
+    public DayEndReportController(IDayEndReportService reports) => _reports = reports;
+
+    /// <summary>One business day (defaults to today in the report's time zone).</summary>
+    [HttpGet]
+    [ProducesResponseType(typeof(DayEndReportDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<DayEndReportDto>> GetDay([FromQuery] DateOnly? date, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _reports.GetDayAsync(date, branchId, ct));
+
+    /// <summary>Day-wise figures for <c>from</c>..<c>to</c> inclusive (at most 92 days).</summary>
+    [HttpGet("daily")]
+    [ProducesResponseType(typeof(DayEndDailyReportDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<DayEndDailyReportDto>> GetDaily([FromQuery] DateOnly from, [FromQuery] DateOnly to, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _reports.GetDailyAsync(from, to, branchId, ct));
+}
diff --git a/Backend/ERPCore/Controllers/ExpenseSetupController.cs b/Backend/ERPCore/Controllers/ExpenseSetupController.cs
new file mode 100644
index 0000000..bd6fea8
--- /dev/null
+++ b/Backend/ERPCore/Controllers/ExpenseSetupController.cs
@@ -0,0 +1,57 @@
+using Microsoft.AspNetCore.Authorization;
+using ERPCore.Dtos.Expenses;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Expense categories and titles (docs/EXPENSE_MODULE_PLAN.md §6 "Setup"). Reading is open to
+/// anyone with Accounts access (the expense form needs the lists); changes need the
+/// Expense Setup permission. Categories are the fixed seeded four — there is no create
+/// endpoint; only their active flag can change. Titles can be added under them.
+/// </summary>
+[Route("api/v1")]
+[Authorize(Policy = NavPolicies.Prefix + "accounts")]
+public sealed class ExpenseSetupController : ApiControllerBase
+{
+    private const string SetupPolicy = NavPolicies.Prefix + "accounts.expense-setup";
+
+    private readonly IExpenseSetupService _setup;
+
+    public ExpenseSetupController(IExpenseSetupService setup) => _setup = setup;
+
+    /// <summary>Categories, each with its titles, in display order.</summary>
+    [HttpGet("expense-categories")]
+    [ProducesResponseType(typeof(IReadOnlyList<ExpenseCategoryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<ExpenseCategoryDto>>> List([FromQuery] bool includeInactive, CancellationToken ct)
+        => Ok(await _setup.ListAsync(includeInactive, ct));
+
+    [HttpPut("expense-categories/{expenseCategoryId:int}")]
+    [Authorize(Policy = SetupPolicy)]
+    [ProducesResponseType(typeof(ExpenseCategoryDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<ExpenseCategoryDto>> UpdateCategory(int expenseCategoryId, [FromBody] UpdateExpenseCategoryRequest request, CancellationToken ct)
+        => Ok(await _setup.UpdateCategoryAsync(expenseCategoryId, request, ct));
+
+    [HttpPost("expense-categories/{expenseCategoryId:int}/titles")]
+    [Authorize(Policy = SetupPolicy)]
+    [ProducesResponseType(typeof(ExpenseTitleDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<ExpenseTitleDto>> CreateTitle(int expenseCategoryId, [FromBody] CreateExpenseTitleRequest request, CancellationToken ct)
+    {
+        var dto = await _setup.CreateTitleAsync(expenseCategoryId, request, ct);
+        return Created($"/api/v1/expense-titles/{dto.ExpenseTitleId}", dto);
+    }
+
+    [HttpPut("expense-titles/{expenseTitleId:int}")]
+    [Authorize(Policy = SetupPolicy)]
+    [ProducesResponseType(typeof(ExpenseTitleDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<ExpenseTitleDto>> UpdateTitle(int expenseTitleId, [FromBody] UpdateExpenseTitleRequest request, CancellationToken ct)
+        => Ok(await _setup.UpdateTitleAsync(expenseTitleId, request, ct));
+}
diff --git a/Backend/ERPCore/Controllers/ExpensesController.cs b/Backend/ERPCore/Controllers/ExpensesController.cs
new file mode 100644
index 0000000..0488524
--- /dev/null
+++ b/Backend/ERPCore/Controllers/ExpensesController.cs
@@ -0,0 +1,127 @@
+using Microsoft.AspNetCore.Authorization;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Expenses;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Business expense bills — draft, post (GL accrual), pay, cancel (docs/EXPENSE_MODULE_PLAN.md §6).</summary>
+[Route("api/v1/expenses")]
+[Authorize(Policy = NavPolicies.Prefix + "accounts.expenses")]
+public sealed class ExpensesController : ApiControllerBase
+{
+    private readonly IExpenseService _expenses;
+    private readonly IExpensePaymentService _payments;
+
+    public ExpensesController(IExpenseService expenses, IExpensePaymentService payments)
+    {
+        _expenses = expenses;
+        _payments = payments;
+    }
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<ExpenseSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<ExpenseSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] ExpenseStatus? status, [FromQuery] ExpensePaymentStatus? paymentStatus,
+        [FromQuery] int? categoryId, [FromQuery] int? titleId, [FromQuery] DateOnly? from, [FromQuery] DateOnly? to,
+        [FromQuery] bool overdueOnly, CancellationToken ct)
+        => Ok(await _expenses.ListAsync(query, new ExpenseListFilter(status, paymentStatus, categoryId, titleId, from, to, overdueOnly), ct));
+
+    /// <summary>Totals by category → title for Posted expenses dated in [from, to] (default: this month), plus unpaid/overdue position.</summary>
+    [HttpGet("summary")]
+    [ProducesResponseType(typeof(ExpenseSummaryReportDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ExpenseSummaryReportDto>> Summary([FromQuery] DateOnly? from, [FromQuery] DateOnly? to, CancellationToken ct)
+        => Ok(await _expenses.GetSummaryAsync(from, to, ct));
+
+    [HttpGet("{expenseId:int}")]
+    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ExpenseDto>> GetById(int expenseId, CancellationToken ct)
+    {
+        var result = await _expenses.GetAsync(expenseId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<ExpenseDto>> Create([FromBody] CreateExpenseRequest request, CancellationToken ct)
+    {
+        var result = await _expenses.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/expenses/{result.Value.ExpenseId}", result.Value);
+    }
+
+    [HttpPut("{expenseId:int}")]
+    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<ExpenseDto>> Update(int expenseId, [FromBody] UpdateExpenseRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _expenses.UpdateAsync(expenseId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    /// <summary>Draft only.</summary>
+    [HttpDelete("{expenseId:int}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<IActionResult> Delete(int expenseId, CancellationToken ct)
+    {
+        await _expenses.DeleteAsync(expenseId, ct);
+        return NoContent();
+    }
+
+    /// <summary>Accrue the expense to GL (Debit expense account / Credit Accrued Expenses).</summary>
+    [HttpPost("{expenseId:int}/post")]
+    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<ExpenseDto>> Post(int expenseId, CancellationToken ct)
+        => Ok(await _expenses.PostAsync(expenseId, ct));
+
+    /// <summary>Post a Draft and pay it, in full or partially, in one transaction; any remainder stays as the balance.</summary>
+    [HttpPost("{expenseId:int}/post-and-pay")]
+    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<ExpenseDto>> PostAndPay(int expenseId, [FromBody] CreateExpensePaymentRequest request, CancellationToken ct)
+        => Ok(await _payments.PostAndPayAsync(expenseId, request, ct));
+
+    /// <summary>Draft, or Posted with no payments (posts the reversing GL entry).</summary>
+    [HttpPost("{expenseId:int}/cancel")]
+    [ProducesResponseType(typeof(ExpenseDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<ExpenseDto>> Cancel(int expenseId, [FromBody] CancelExpenseRequest request, CancellationToken ct)
+        => Ok(await _expenses.CancelAsync(expenseId, request, ct));
+
+    /// <summary>Pay against the balance, in full or in installments; one GL entry per submission.</summary>
+    [HttpPost("{expenseId:int}/payments")]
+    [ProducesResponseType(typeof(IReadOnlyList<ExpensePaymentDto>), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<IReadOnlyList<ExpensePaymentDto>>> Pay(int expenseId, [FromBody] CreateExpensePaymentRequest request, CancellationToken ct)
+    {
+        var rows = await _payments.PayAsync(expenseId, request, ct);
+        return Created($"/api/v1/expenses/{expenseId}/payments", rows);
+    }
+
+    /// <summary>Payment history, newest first.</summary>
+    [HttpGet("{expenseId:int}/payments")]
+    [ProducesResponseType(typeof(IReadOnlyList<ExpensePaymentDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<IReadOnlyList<ExpensePaymentDto>>> ListPayments(int expenseId, CancellationToken ct)
+        => Ok(await _payments.ListAsync(expenseId, ct));
+}
diff --git a/Backend/ERPCore/Controllers/ItemsController.cs b/Backend/ERPCore/Controllers/ItemsController.cs
index b420a19..8f3dbe2 100644
--- a/Backend/ERPCore/Controllers/ItemsController.cs
+++ b/Backend/ERPCore/Controllers/ItemsController.cs
@@ -57,6 +57,13 @@ public sealed class ItemsController : ApiControllerBase
         return result is null ? NotFound() : Ok(result);
     }
 
+    /// <summary>The item's latest posted GRN receipts (default 5, newest first): unit cost, discount, net cost, vendor.</summary>
+    [HttpGet("{itemId:int}/purchase-prices")]
+    [ProducesResponseType(typeof(IReadOnlyList<ItemPurchasePriceDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<IReadOnlyList<ItemPurchasePriceDto>>> PurchasePrices(int itemId, [FromQuery] int take, CancellationToken ct)
+        => Ok(await _items.GetPurchasePricesAsync(itemId, take <= 0 ? 5 : take, ct));
+
     /// <summary>Get a single item; returns an <c>ETag</c> for optimistic concurrency.</summary>
     [HttpGet("{itemId:int}")]
     [ProducesResponseType(typeof(ItemDetailDto), StatusCodes.Status200OK)]
diff --git a/Backend/ERPCore/Controllers/PriceAdjustmentsController.cs b/Backend/ERPCore/Controllers/PriceAdjustmentsController.cs
new file mode 100644
index 0000000..0f9fe51
--- /dev/null
+++ b/Backend/ERPCore/Controllers/PriceAdjustmentsController.cs
@@ -0,0 +1,89 @@
+using Microsoft.AspNetCore.Authorization;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Approvals;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Products;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Selling-price change requests (docs/DUAL_APPROVAL_PLAN.md §6.4). Requesting needs Create on
+/// <c>products.price-adjustments</c>, deciding needs Approve; an item's applied price history is
+/// readable by anyone who can see Products.
+/// </summary>
+[Route("api/v1/price-adjustments")]
+[Authorize(Policy = NavPolicies.Prefix + "products")]
+public sealed class PriceAdjustmentsController : ApiControllerBase
+{
+    private const string Screen = NavPolicies.Prefix + "products.price-adjustments";
+    private const string CreatePolicy = Screen + NavPolicies.ActionSeparator + NavPolicies.CreateAction;
+    private const string ApprovePolicy = Screen + NavPolicies.ActionSeparator + NavPolicies.ApproveAction;
+
+    private readonly IPriceAdjustmentService _prices;
+
+    public PriceAdjustmentsController(IPriceAdjustmentService prices) => _prices = prices;
+
+    [HttpGet]
+    [Authorize(Policy = Screen)]
+    [ProducesResponseType(typeof(PagedResponse<PriceAdjustmentSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<PriceAdjustmentSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] PriceAdjustmentStatus? status, [FromQuery] int? itemId, CancellationToken ct)
+        => Ok(await _prices.ListAsync(query, status, itemId, ct));
+
+    [HttpGet("{priceAdjustmentId:int}")]
+    [Authorize(Policy = Screen)]
+    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<PriceAdjustmentDto>> GetById(int priceAdjustmentId, CancellationToken ct)
+    {
+        var dto = await _prices.GetAsync(priceAdjustmentId, ct);
+        return dto is null ? NotFound() : Ok(dto);
+    }
+
+    /// <summary>Request new selling prices for one or more items.</summary>
+    [HttpPost]
+    [Authorize(Policy = CreatePolicy)]
+    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PriceAdjustmentDto>> Create([FromBody] CreatePriceAdjustmentRequest request, CancellationToken ct)
+    {
+        var dto = await _prices.CreateAsync(request, ct);
+        return Created($"/api/v1/price-adjustments/{dto.PriceAdjustmentId}", dto);
+    }
+
+    /// <summary>Give the next approval; the final one applies the prices.</summary>
+    [HttpPost("{priceAdjustmentId:int}/approve")]
+    [Authorize(Policy = ApprovePolicy)]
+    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status403Forbidden)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PriceAdjustmentDto>> Approve(int priceAdjustmentId, [FromBody] ApproveRequest? request, CancellationToken ct)
+        => Ok(await _prices.ApproveAsync(priceAdjustmentId, request?.Comment, ct));
+
+    [HttpPost("{priceAdjustmentId:int}/reject")]
+    [Authorize(Policy = ApprovePolicy)]
+    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status403Forbidden)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PriceAdjustmentDto>> Reject(int priceAdjustmentId, [FromBody] RejectRequest request, CancellationToken ct)
+        => Ok(await _prices.RejectAsync(priceAdjustmentId, request.Reason, ct));
+
+    /// <summary>The requester withdraws a pending request.</summary>
+    [HttpPost("{priceAdjustmentId:int}/cancel")]
+    [Authorize(Policy = Screen)]
+    [ProducesResponseType(typeof(PriceAdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status403Forbidden)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PriceAdjustmentDto>> Cancel(int priceAdjustmentId, CancellationToken ct)
+        => Ok(await _prices.CancelAsync(priceAdjustmentId, ct));
+
+    /// <summary>Every applied price change for an item, newest first, with who approved it.</summary>
+    [HttpGet("/api/v1/items/{itemId:int}/price-history")]
+    [ProducesResponseType(typeof(IReadOnlyList<ItemPriceHistoryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<ItemPriceHistoryDto>>> ItemHistory(int itemId, CancellationToken ct)
+        => Ok(await _prices.ItemHistoryAsync(itemId, ct));
+}
diff --git a/Backend/ERPCore/Controllers/SerialsController.cs b/Backend/ERPCore/Controllers/SerialsController.cs
new file mode 100644
index 0000000..ba90c36
--- /dev/null
+++ b/Backend/ERPCore/Controllers/SerialsController.cs
@@ -0,0 +1,41 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Stock;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Serial register and per-serial history (docs/ITEM_TRACKING_PLAN.md Phase 9).</summary>
+[Route("api/v1/serials")]
+[Authorize(Policy = NavPolicies.Prefix + "stock")]
+public sealed class SerialsController : ApiControllerBase
+{
+    private readonly IItemTrackingService _tracking;
+
+    public SerialsController(IItemTrackingService tracking) => _tracking = tracking;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SerialSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SerialSummaryDto>>> List(
+        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] SerialStatus? status,
+        [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _tracking.ListSerialsAsync(query, itemId, warehouseId, status, ct));
+
+    /// <summary>Exact lookup by serial number or barcode, across items.</summary>
+    [HttpGet("lookup")]
+    [ProducesResponseType(typeof(IReadOnlyList<SerialDetailDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SerialDetailDto>>> Lookup([FromQuery] string serialNo, CancellationToken ct)
+        => Ok(await _tracking.FindSerialAsync(serialNo, ct));
+
+    [HttpGet("{serialId:int}")]
+    [ProducesResponseType(typeof(SerialDetailDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SerialDetailDto>> Get(int serialId, CancellationToken ct)
+    {
+        var dto = await _tracking.GetSerialAsync(serialId, ct);
+        return dto is null ? NotFound() : Ok(dto);
+    }
+}
diff --git a/Backend/ERPCore/Controllers/StockAdjustmentsController.cs b/Backend/ERPCore/Controllers/StockAdjustmentsController.cs
index 1b10b37..5f8e6e0 100644
--- a/Backend/ERPCore/Controllers/StockAdjustmentsController.cs
+++ b/Backend/ERPCore/Controllers/StockAdjustmentsController.cs
@@ -1,5 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
+using ERPCore.Domain.Enums;
 using ERPCore.Infra.Auth;
+using ERPCore.Dtos.Approvals;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Stock;
 using ERPCore.Services.Interfaces;
@@ -7,23 +9,30 @@ using Microsoft.AspNetCore.Mvc;
 
 namespace ERPCore.Controllers;
 
-/// <summary>Stock-adjustment endpoints (docs/11 §5.5).</summary>
+/// <summary>
+/// Stock-adjustment endpoints (docs/11 §5.5). Creating submits a request; it moves stock once
+/// approved (docs/DUAL_APPROVAL_PLAN.md §5.4). Approving or rejecting needs the Approve action on
+/// <c>stock.adjustments</c>; the two-person rules are enforced by the service.
+/// </summary>
 [Route("api/v1/stock-adjustments")]
 [Authorize(Policy = NavPolicies.Prefix + "stock")]
 public sealed class StockAdjustmentsController : ApiControllerBase
 {
+    private const string ApprovePolicy = NavPolicies.Prefix + "stock.adjustments" + NavPolicies.ActionSeparator + NavPolicies.ApproveAction;
+
     private readonly IAdjustmentService _adjustments;
 
     public StockAdjustmentsController(IAdjustmentService adjustments) => _adjustments = adjustments;
 
-    /// <summary>List posted adjustments, newest first.</summary>
+    /// <summary>List adjustments (posted and requests), newest first.</summary>
     [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? branchId, [FromQuery] int? reasonCodeId,
+        [FromQuery] AdjustmentStatus? status, CancellationToken ct)
+        => Ok(await _adjustments.ListAsync(query, warehouseId, branchId, reasonCodeId, status, ct));
 
-    /// <summary>Get one adjustment with its lines and the ledger entries it posted.</summary>
+    /// <summary>Get one adjustment with its lines, approval trail and the ledger entries it posted.</summary>
     [HttpGet("{adjustmentId:int}")]
     [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
@@ -33,7 +42,7 @@ public sealed class StockAdjustmentsController : ApiControllerBase
         return dto is null ? NotFound() : Ok(dto);
     }
 
-    /// <summary>Create + auto-post an adjustment (mandatory reason code; decrease FIFO-consumes).</summary>
+    /// <summary>Submit an adjustment (mandatory reason code). Posts at once only when approvals are off.</summary>
     [HttpPost]
     [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status201Created)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
@@ -44,4 +53,29 @@ public sealed class StockAdjustmentsController : ApiControllerBase
         var dto = await _adjustments.CreateAsync(request, ct);
         return Created($"/api/v1/stock-adjustments/{dto.AdjustmentId}", dto);
     }
+
+    /// <summary>Give the next approval. The final one posts the stock movement and GL.</summary>
+    [HttpPost("{adjustmentId:int}/approve")]
+    [Authorize(Policy = ApprovePolicy)]
+    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status403Forbidden)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<AdjustmentDto>> Approve(int adjustmentId, [FromBody] ApproveRequest? request, CancellationToken ct)
+        => Ok(await _adjustments.ApproveAsync(adjustmentId, request?.Comment, ct));
+
+    [HttpPost("{adjustmentId:int}/reject")]
+    [Authorize(Policy = ApprovePolicy)]
+    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status403Forbidden)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<AdjustmentDto>> Reject(int adjustmentId, [FromBody] RejectRequest request, CancellationToken ct)
+        => Ok(await _adjustments.RejectAsync(adjustmentId, request.Reason, ct));
+
+    /// <summary>The requester withdraws a pending request.</summary>
+    [HttpPost("{adjustmentId:int}/cancel")]
+    [ProducesResponseType(typeof(AdjustmentDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status403Forbidden)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<AdjustmentDto>> Cancel(int adjustmentId, CancellationToken ct)
+        => Ok(await _adjustments.CancelAsync(adjustmentId, ct));
 }
diff --git a/Backend/ERPCore/Controllers/StockController.cs b/Backend/ERPCore/Controllers/StockController.cs
index 7e4436a..01e5363 100644
--- a/Backend/ERPCore/Controllers/StockController.cs
+++ b/Backend/ERPCore/Controllers/StockController.cs
@@ -15,13 +15,26 @@ public sealed class StockController : ApiControllerBase
 {
     private readonly IStockService _stock;
     private readonly IReorderService _reorder;
+    private readonly IItemTrackingService _tracking;
 
-    public StockController(IStockService stock, IReorderService reorder)
+    public StockController(IStockService stock, IReorderService reorder, IItemTrackingService tracking)
     {
         _stock = stock;
         _reorder = reorder;
+        _tracking = tracking;
     }
 
+    /// <summary>
+    /// Stock on hand per batch with expiry (docs/ITEM_TRACKING_PLAN.md Phase 9), soonest expiry
+    /// first. <c>expiringWithinDays</c> keeps batches expiring within that window, expired included.
+    /// </summary>
+    [HttpGet("batches")]
+    [ProducesResponseType(typeof(PagedResponse<BatchStockDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<BatchStockDto>>> Batches(
+        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] int? expiringWithinDays,
+        [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _tracking.ListBatchStockAsync(query, itemId, warehouseId, expiringWithinDays, ct));
+
     [HttpGet("on-hand")]
     [ProducesResponseType(typeof(StockOnHandDto), StatusCodes.Status200OK)]
     public async Task<ActionResult<StockOnHandDto>> OnHand([FromQuery] int itemId, [FromQuery] int warehouseId, CancellationToken ct)
diff --git a/Backend/ERPCore/Controllers/TrackingController.cs b/Backend/ERPCore/Controllers/TrackingController.cs
new file mode 100644
index 0000000..5c2a14f
--- /dev/null
+++ b/Backend/ERPCore/Controllers/TrackingController.cs
@@ -0,0 +1,64 @@
+using ERPCore.Dtos.Stock;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Serial/batch pickers used across GRN, sales, returns and stock screens
+/// (docs/ITEM_TRACKING_PLAN.md Phase 8). Read-only lookups like the item scan, so they need
+/// only ERP access — not one module's nav permission — as every one of those screens calls them.
+/// </summary>
+[Route("api/v1/tracking")]
+public sealed class TrackingController : ApiControllerBase
+{
+    private readonly IItemTrackingService _tracking;
+    private readonly ISerialTrackingService _serialTracking;
+
+    public TrackingController(IItemTrackingService tracking, ISerialTrackingService serialTracking)
+    {
+        _tracking = tracking;
+        _serialTracking = serialTracking;
+    }
+
+    /// <summary>
+    /// Which tracking features are switched on (Product Configuration) — readable by every
+    /// screen, unlike <c>/product-config</c> which needs the Products permission.
+    /// </summary>
+    [HttpGet("settings")]
+    [ProducesResponseType(typeof(TrackingSettingsDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<TrackingSettingsDto>> Settings(CancellationToken ct)
+        => Ok(new TrackingSettingsDto(await _serialTracking.IsEnabledAsync(ct)));
+
+    /// <summary>
+    /// Auto-generate: the next <c>count</c> free serial numbers for an item under <c>prefix</c>
+    /// (continues the highest number already used). Nothing is reserved — the GRN still checks
+    /// uniqueness when it is saved and confirmed.
+    /// </summary>
+    [HttpGet("serials/next-numbers")]
+    [ProducesResponseType(typeof(IReadOnlyList<string>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<string>>> NextSerialNumbers(
+        [FromQuery] int itemId, [FromQuery] string? prefix, [FromQuery] int count = 1, CancellationToken ct = default)
+        => Ok(await _tracking.NextSerialNumbersAsync(itemId, prefix ?? string.Empty, count, ct));
+
+    /// <summary>Issuable serials of an item at a warehouse (search by number/barcode with <c>q</c>).</summary>
+    [HttpGet("serials/available")]
+    [ProducesResponseType(typeof(IReadOnlyList<AvailableSerialDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<AvailableSerialDto>>> AvailableSerials(
+        [FromQuery] int itemId, [FromQuery] int warehouseId, [FromQuery] string? q, [FromQuery] int take = 200, CancellationToken ct = default)
+        => Ok(await _tracking.GetAvailableSerialsAsync(itemId, warehouseId, q, take, ct));
+
+    /// <summary>Issuable stock per batch with expiry, soonest expiry first.</summary>
+    [HttpGet("batches/available")]
+    [ProducesResponseType(typeof(IReadOnlyList<AvailableBatchDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<AvailableBatchDto>>> AvailableBatches(
+        [FromQuery] int itemId, [FromQuery] int warehouseId, CancellationToken ct)
+        => Ok(await _tracking.GetAvailableBatchesAsync(itemId, warehouseId, ct));
+
+    /// <summary>The FEFO pick posting would make for <c>qty</c> when no batch is chosen.</summary>
+    [HttpGet("batches/suggest")]
+    [ProducesResponseType(typeof(IReadOnlyList<BatchSuggestionDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<BatchSuggestionDto>>> SuggestBatches(
+        [FromQuery] int itemId, [FromQuery] int warehouseId, [FromQuery] decimal qty, CancellationToken ct)
+        => Ok(await _tracking.SuggestBatchesAsync(itemId, warehouseId, qty, ct));
+}
diff --git a/Backend/ERPCore/Controllers/VendorsController.cs b/Backend/ERPCore/Controllers/VendorsController.cs
index 29f3175..05199c7 100644
--- a/Backend/ERPCore/Controllers/VendorsController.cs
+++ b/Backend/ERPCore/Controllers/VendorsController.cs
@@ -65,4 +65,15 @@ public sealed class VendorsController : ApiControllerBase
         await _vendors.SetStatusAsync(vendorId, request.Status, ct);
         return NoContent();
     }
+
+    [HttpDelete("{vendorId:int}")]
+    [Authorize(Policy = NavPolicies.Prefix + "vendors" + NavPolicies.ActionSeparator + NavPolicies.DeleteAction)]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<IActionResult> Delete(int vendorId, CancellationToken ct)
+    {
+        await _vendors.DeleteAsync(vendorId, ct);
+        return NoContent();
+    }
 }
diff --git a/Backend/ERPCore/Controllers/WarrantiesController.cs b/Backend/ERPCore/Controllers/WarrantiesController.cs
new file mode 100644
index 0000000..0a9cb25
--- /dev/null
+++ b/Backend/ERPCore/Controllers/WarrantiesController.cs
@@ -0,0 +1,30 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Stock;
+using ERPCore.Infra.Auth;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Customer warranty register (docs/ITEM_TRACKING_PLAN.md Phase 5). Warranties are created by
+/// posting a sale, never directly — this controller only reads.
+/// </summary>
+[Route("api/v1/warranties")]
+[Authorize(Policy = NavPolicies.Prefix + "sales")]
+public sealed class WarrantiesController : ApiControllerBase
+{
+    private readonly IItemTrackingService _tracking;
+
+    public WarrantiesController(IItemTrackingService tracking) => _tracking = tracking;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<WarrantyRegistrationDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<WarrantyRegistrationDto>>> List(
+        [FromQuery] int? customerId, [FromQuery] int? itemId, [FromQuery] string? serialNo,
+        [FromQuery] WarrantyStatus? status, [FromQuery] int? expiringWithinDays, [FromQuery] bool? expired,
+        [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _tracking.ListWarrantiesAsync(query, customerId, itemId, serialNo, status, expiringWithinDays, expired, ct));
+}
diff --git a/Backend/ERPCore/Domain/DocumentTypes.cs b/Backend/ERPCore/Domain/DocumentTypes.cs
index f00ad99..1fe3fdb 100644
--- a/Backend/ERPCore/Domain/DocumentTypes.cs
+++ b/Backend/ERPCore/Domain/DocumentTypes.cs
@@ -26,4 +26,13 @@ public static class DocumentTypes
 
     /// <summary>Cashier day-end close-out (Sales) — <c>DEND-2026-00001</c>.</summary>
     public const string SalesDayEnd = "DEND";
+
+    /// <summary>Business expense bill (Accounts) — <c>EXP-BR-001-2026-00001</c>.</summary>
+    public const string Expense = "EXP";
+
+    /// <summary>Till cash deposited to a bank account (Accounts) — <c>BD-BR-001-2026-00001</c>.</summary>
+    public const string BankDeposit = "BD";
+
+    /// <summary>Selling-price change request (Products) — <c>PADJ-2026-00001</c>.</summary>
+    public const string PriceAdjustment = "PADJ";
 }
diff --git a/Backend/ERPCore/Domain/Entities/BankDeposit.cs b/Backend/ERPCore/Domain/Entities/BankDeposit.cs
new file mode 100644
index 0000000..57e01a2
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/BankDeposit.cs
@@ -0,0 +1,55 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Till cash taken to the bank (docs/BANK_DEPOSIT_MODULE_PLAN.md §4). Saving it posts a GL entry
+/// (Debit the bank account / Credit the cash account) and lowers the branch's cash in hand for
+/// <see cref="BusinessDate"/>. There is no draft: a wrong deposit is cancelled (the entry is
+/// reversed) and entered again. GL accounts have no local FK, so the account details are snapshots.
+/// </summary>
+public class BankDeposit
+{
+    public int BankDepositId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public int BranchId { get; set; }
+    public Branch? Branch { get; set; }
+
+    /// <summary>The day whose cash is deposited — cash in hand and the day-end report group by this.</summary>
+    public DateOnly BusinessDate { get; set; }
+    /// <summary>The day the bank received it; the GL entry date.</summary>
+    public DateOnly DepositDate { get; set; }
+
+    public decimal Amount { get; set; }
+
+    public long FromGlCashAccountId { get; set; }
+    public string FromCashAccountCode { get; set; } = string.Empty;
+    public string FromCashAccountName { get; set; } = string.Empty;
+
+    public long ToGlBankAccountId { get; set; }
+    public string ToBankAccountCode { get; set; } = string.Empty;
+    public string ToBankAccountName { get; set; } = string.Empty;
+    public string? ToBankName { get; set; }
+    public string? ToAccountNumber { get; set; }
+
+    public string? DepositSlipNo { get; set; }
+    public string? DepositedBy { get; set; }
+    public string? Remarks { get; set; }
+
+    public BankDepositStatus Status { get; set; } = BankDepositStatus.Posted;
+
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { get; set; }
+
+    public string? GlReversalJournalNo { get; set; }
+    public string? CancelReason { get; set; }
+    public int? CancelledBy { get; set; }
+    public DateTime? CancelledAt { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+    public DateTime CreatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/BundleSale.cs b/Backend/ERPCore/Domain/Entities/BundleSale.cs
index c0109ac..a195f29 100644
--- a/Backend/ERPCore/Domain/Entities/BundleSale.cs
+++ b/Backend/ERPCore/Domain/Entities/BundleSale.cs
@@ -25,6 +25,11 @@ public class BundleSale
     public decimal DiscountTotal { get; set; }
     public decimal TaxTotal { get; set; }
     public decimal GrandTotal { get; set; }
+
+    /// <summary>How the (always fully paid) <see cref="GrandTotal"/> was tendered:
+    /// <c>CashAmount + CardAmount == GrandTotal</c>. Backfilled as all cash.</summary>
+    public decimal CashAmount { get; set; }
+    public decimal CardAmount { get; set; }
     public DateTime CreatedAt { get; set; }
     public DateTime? UpdatedAt { get; set; }
     public uint RowVersion { get; set; }
diff --git a/Backend/ERPCore/Domain/Entities/DocumentApproval.cs b/Backend/ERPCore/Domain/Entities/DocumentApproval.cs
new file mode 100644
index 0000000..eaffa73
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/DocumentApproval.cs
@@ -0,0 +1,48 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One approval decision on a document (docs/DUAL_APPROVAL_PLAN.md §4.1) — a row per decision, so
+/// the full trail survives. Polymorphic like the stock ledger: <see cref="DocType"/> +
+/// <see cref="DocId"/>, no FK. Doc types: <c>ADJ</c> (stock adjustment), <c>PADJ</c> (price adjustment).
+/// </summary>
+public class DocumentApproval
+{
+    public int DocumentApprovalId { get; set; }
+    public string DocType { get; set; } = string.Empty;
+    public int DocId { get; set; }
+    /// <summary>1 or 2.</summary>
+    public int Level { get; set; }
+    public ApprovalDecision Decision { get; set; }
+    public int DecidedBy { get; set; }
+    public User? Decider { get; set; }
+    public DateTime DecidedAt { get; set; }
+    public string? Comment { get; set; }
+}
+
+/// <summary>
+/// Approval rules (docs/DUAL_APPROVAL_PLAN.md §7). Singleton row, edited under Settings → Approvals.
+/// Levels: 0 = no approval (applies on create), 1 = one approver, 2 = two different approvers.
+/// </summary>
+public class ApprovalConfig
+{
+    public const int SingletonId = 1;
+
+    public int ApprovalConfigId { get; set; }
+
+    public int StockAdjustmentLevels { get; set; } = 2;
+    /// <summary>With 2 levels: an adjustment whose stock value is below this needs only one approval. 0 = always two.</summary>
+    public decimal StockAdjustmentLevel2ThresholdValue { get; set; }
+
+    public int PriceAdjustmentLevels { get; set; } = 2;
+    /// <summary>With 2 levels: a change smaller than this percent (largest across its lines) needs only one approval. 0 = always two.</summary>
+    public decimal PriceAdjustmentLevel2ThresholdPercent { get; set; }
+
+    /// <summary>Comma-separated role codes allowed to give the second approval; empty = anyone with the Approve action.</summary>
+    public string? Level2RoleCodes { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+    public int? UpdatedBy { get; set; }
+    public uint RowVersion { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/Expense.cs b/Backend/ERPCore/Domain/Entities/Expense.cs
new file mode 100644
index 0000000..14c4f3b
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/Expense.cs
@@ -0,0 +1,92 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One business expense bill (electricity, rent, …) outside procurement. Draft is editable;
+/// Post accrues it to GL (Debit the title's expense account / Credit Accrued Expenses);
+/// payments then settle the accrual in one or more installments (see
+/// ExpensePaymentService). Model: docs/EXPENSE_MODULE_PLAN.md §3.3.
+/// </summary>
+public class Expense
+{
+    public int ExpenseId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public int BranchId { get; set; }
+    public Branch? Branch { get; set; }
+
+    public DateOnly ExpenseDate { get; set; }
+    public DateOnly? DueDate { get; set; }
+
+    public int ExpenseCategoryId { get; set; }
+    public ExpenseCategory? Category { get; set; }
+
+    public int ExpenseTitleId { get; set; }
+    public ExpenseTitle? Title { get; set; }
+
+    public string? Payee { get; set; }
+    public int? VendorId { get; set; }
+    public Vendor? Vendor { get; set; }
+
+    public string? BillReference { get; set; }
+    public string? Description { get; set; }
+    /// <summary>Optional month the bill covers, as <c>yyyy-MM</c> (e.g. September's electricity).</summary>
+    public string? PeriodMonth { get; set; }
+
+    public decimal Amount { get; set; }
+    public decimal PaidAmount { get; set; }
+    public decimal BalanceAmount { get; set; }
+
+    public ExpenseStatus Status { get; set; } = ExpenseStatus.Draft;
+    public ExpensePaymentStatus PaymentStatus { get; set; } = ExpensePaymentStatus.Unpaid;
+
+    /// <summary>Snapshot of the title's GL expense account at post time.</summary>
+    public string? GlExpenseAccountCode { get; set; }
+    /// <summary>Journal number of the accrual entry posted on Post.</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { get; set; }
+    /// <summary>Journal number of the reversing entry posted on Cancel (Posted expenses only).</summary>
+    public string? GlReversalJournalNo { get; set; }
+    public string? CancelReason { 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<ExpensePayment> Payments { get; set; } = new List<ExpensePayment>();
+}
+
+/// <summary>
+/// A payment against a Posted expense's balance (installments allowed). Every line of one
+/// payment submission shares the single GL journal entry that submission posted (Debit
+/// Accrued Expenses / Credit each selected cash-or-bank account). Mirrors
+/// <see cref="PurchaseInvoicePayment"/>.
+/// </summary>
+public class ExpensePayment
+{
+    public int ExpensePaymentId { get; set; }
+
+    public int ExpenseId { get; set; }
+    public Expense? Expense { get; set; }
+
+    public decimal Amount { get; set; }
+    public DateTime PaymentDate { get; set; }
+    public ExpensePaymentMethod PaymentMethod { 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? ChequeNo { get; set; }
+    public string? Reference { get; set; }
+    public string? GlJournalNo { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+    public DateTime CreatedAt { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/ExpenseCategory.cs b/Backend/ERPCore/Domain/Entities/ExpenseCategory.cs
new file mode 100644
index 0000000..2062573
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/ExpenseCategory.cs
@@ -0,0 +1,48 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Top-level expense grouping (Utility, Rental, Salaries, Other). The four seeded rows are
+/// <see cref="IsSystem"/> — they can be deactivated but not renamed; admins can add more.
+/// Each category owns its <see cref="ExpenseTitle"/>s. Model: docs/EXPENSE_MODULE_PLAN.md §3.1.
+/// </summary>
+public class ExpenseCategory
+{
+    public int ExpenseCategoryId { get; set; }
+    public string Code { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public bool IsSystem { get; set; }
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+    public int SortOrder { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public uint RowVersion { get; set; }
+
+    public ICollection<ExpenseTitle> Titles { get; set; } = new List<ExpenseTitle>();
+}
+
+/// <summary>
+/// A specific expense under a category (Utility → Electricity, Water, …). Carries the GL
+/// expense account debited when an expense with this title is posted — snapshotted onto the
+/// expense at post time, so changing it later does not touch already-posted expenses.
+/// Model: docs/EXPENSE_MODULE_PLAN.md §3.2.
+/// </summary>
+public class ExpenseTitle
+{
+    public int ExpenseTitleId { get; set; }
+
+    public int ExpenseCategoryId { get; set; }
+    public ExpenseCategory? Category { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+    public string GlExpenseAccountCode { get; set; } = string.Empty;
+    public bool IsSystem { get; set; }
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+    public int SortOrder { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public uint RowVersion { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/GrnLine.cs b/Backend/ERPCore/Domain/Entities/GrnLine.cs
index 74ed6d1..f451205 100644
--- a/Backend/ERPCore/Domain/Entities/GrnLine.cs
+++ b/Backend/ERPCore/Domain/Entities/GrnLine.cs
@@ -65,4 +65,12 @@ public class GrnLine
     /// Empty for a non-warranty item.
     /// </summary>
     public ICollection<GrnLineWarrantyNumber> WarrantyNumbers { get; set; } = new List<GrnLineWarrantyNumber>();
+
+    /// <summary>
+    /// One row per received unit when <see cref="Item.TrackingMode"/> is
+    /// <see cref="TrackingMode.Serial"/> — count must equal <see cref="Qty"/>. For a serial item
+    /// under warranty the serial is the warranty identity, so it carries no
+    /// <see cref="WarrantyNumbers"/>. Empty otherwise.
+    /// </summary>
+    public ICollection<GrnLineSerial> Serials { get; set; } = new List<GrnLineSerial>();
 }
diff --git a/Backend/ERPCore/Domain/Entities/GrnLineSerial.cs b/Backend/ERPCore/Domain/Entities/GrnLineSerial.cs
new file mode 100644
index 0000000..e1bfca6
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/GrnLineSerial.cs
@@ -0,0 +1,22 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A serial number captured on a Draft GRN line for a serial-tracked item
+/// (<see cref="Item.TrackingMode"/> = <see cref="Enums.TrackingMode.Serial"/>). The line must
+/// carry exactly <see cref="GrnLine.Qty"/> of these. The draft holds the numbers only — the
+/// <see cref="Serial"/> rows (and their qty-1 FIFO layers) are created when the GRN is
+/// confirmed, so a draft that is never confirmed reserves nothing (docs/ITEM_TRACKING_PLAN.md Phase 2).
+/// </summary>
+public class GrnLineSerial
+{
+    public int GrnLineSerialId { get; set; }
+
+    public int GrnLineId { get; set; }
+    public GrnLine? GrnLine { get; set; }
+
+    public string SerialNo { get; set; } = string.Empty;
+
+    /// <summary>Set on confirm — the <see cref="Serial"/> created for this number.</summary>
+    public int? SerialId { get; set; }
+    public Serial? Serial { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/PriceAdjustment.cs b/Backend/ERPCore/Domain/Entities/PriceAdjustment.cs
new file mode 100644
index 0000000..0089dd4
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/PriceAdjustment.cs
@@ -0,0 +1,78 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A request to change items' selling prices (docs/DUAL_APPROVAL_PLAN.md §6). Nothing changes on the
+/// items until it is fully approved; then each line's new prices are written to its item and an
+/// <see cref="ItemPriceHistory"/> row is kept. <see cref="CreatedBy"/> is the requester.
+/// </summary>
+public class PriceAdjustment
+{
+    public int PriceAdjustmentId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+    public string Reason { get; set; } = string.Empty;
+
+    public PriceAdjustmentStatus Status { get; set; } = PriceAdjustmentStatus.PendingApproval;
+    public int RequiredApprovals { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+    public DateTime CreatedAt { get; set; }
+
+    public int? ApprovedLevel1By { get; set; }
+    public DateTime? ApprovedLevel1At { get; set; }
+    public int? ApprovedLevel2By { get; set; }
+    public DateTime? ApprovedLevel2At { get; set; }
+    public int? RejectedBy { get; set; }
+    public DateTime? RejectedAt { get; set; }
+    public string? RejectReason { get; set; }
+    public DateTime? CancelledAt { get; set; }
+    /// <summary>When the new prices were written to the items.</summary>
+    public DateTime? AppliedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<PriceAdjustmentLine> Lines { get; set; } = new List<PriceAdjustmentLine>();
+}
+
+/// <summary>One item's change. The Old* values are the item's prices when the request was made —
+/// approval fails if the item has been repriced since (stale request).</summary>
+public class PriceAdjustmentLine
+{
+    public int PriceAdjustmentLineId { get; set; }
+    public int PriceAdjustmentId { get; set; }
+    public PriceAdjustment? PriceAdjustment { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public decimal? OldMinPrice { get; set; }
+    public decimal? OldMaxPrice { get; set; }
+    public decimal? OldFlatPrice { get; set; }
+    public decimal? NewMinPrice { get; set; }
+    public decimal? NewMaxPrice { get; set; }
+    public decimal? NewFlatPrice { get; set; }
+}
+
+/// <summary>An applied selling-price change: what it was, what it became, and who approved it.</summary>
+public class ItemPriceHistory
+{
+    public int ItemPriceHistoryId { get; set; }
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+    public int? PriceAdjustmentId { get; set; }
+    public PriceAdjustment? PriceAdjustment { get; set; }
+
+    public decimal? OldMinPrice { get; set; }
+    public decimal? OldMaxPrice { get; set; }
+    public decimal? OldFlatPrice { get; set; }
+    public decimal? NewMinPrice { get; set; }
+    public decimal? NewMaxPrice { get; set; }
+    public decimal? NewFlatPrice { get; set; }
+
+    public int RequestedBy { get; set; }
+    public int? ApprovedLevel1By { get; set; }
+    public int? ApprovedLevel2By { get; set; }
+    public DateTime AppliedAt { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs b/Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs
index d8ff592..27aad21 100644
--- a/Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs
+++ b/Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs
@@ -19,6 +19,13 @@ public class SalesInvoiceLine
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 
+    /// <summary>Pins the line to one batch; null lets posting pick batches FEFO.</summary>
+    public int? BatchId { get; set; }
+    public Batch? Batch { get; set; }
+
+    /// <summary>Chosen serials for a serial-tracked item (one per unit of Qty + FreeQty).</summary>
+    public ICollection<SalesInvoiceLineSerial> Serials { get; set; } = new List<SalesInvoiceLineSerial>();
+
     public decimal UnitPrice { get; set; }
     public decimal BaseCost { get; set; }
     public string PriceSource { get; set; } = string.Empty;
diff --git a/Backend/ERPCore/Domain/Entities/SalesInvoicePayment.cs b/Backend/ERPCore/Domain/Entities/SalesInvoicePayment.cs
index 27705b3..20c2e97 100644
--- a/Backend/ERPCore/Domain/Entities/SalesInvoicePayment.cs
+++ b/Backend/ERPCore/Domain/Entities/SalesInvoicePayment.cs
@@ -1,3 +1,5 @@
+using ERPCore.Domain.Enums;
+
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
@@ -21,6 +23,9 @@ public class SalesInvoicePayment
     /// <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;
 
+    /// <summary>How the customer paid. Payments recorded before this existed were backfilled as Cash.</summary>
+    public SalesPaymentMethod PaymentMethod { get; set; } = SalesPaymentMethod.Cash;
+
     public string? Reference { get; set; }
 
     /// <summary>Journal number of the real GL journal entry this payment posted.</summary>
diff --git a/Backend/ERPCore/Domain/Entities/SalesLineAllocation.cs b/Backend/ERPCore/Domain/Entities/SalesLineAllocation.cs
new file mode 100644
index 0000000..d545915
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/SalesLineAllocation.cs
@@ -0,0 +1,35 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// What a posted sales line actually issued: one row per consumed FIFO segment, carrying the
+/// batch (FEFO-picked when the line named none) and, for serial items, the serial. The source
+/// line is referenced polymorphically (<see cref="SourceDocType"/> is a
+/// <see cref="Domain.DocumentTypes"/> value) — same convention as <see cref="StockLedger"/> —
+/// so invoices, slips and bundles share one table. Returns read it to restock into the same
+/// batch/serial (docs/ITEM_TRACKING_PLAN.md Phases 4 and 6).
+/// </summary>
+public class SalesLineAllocation
+{
+    public int SalesLineAllocationId { get; set; }
+
+    public string SourceDocType { get; set; } = string.Empty;
+    public int SourceDocId { get; set; }
+    public int SourceLineId { get; set; }
+
+    public int ItemId { get; set; }
+    public int WarehouseId { get; set; }
+
+    public int? BatchId { get; set; }
+    public Batch? Batch { get; set; }
+
+    public int? SerialId { get; set; }
+    public Serial? Serial { get; set; }
+
+    public decimal Qty { get; set; }
+    public decimal UnitCost { get; set; }
+
+    /// <summary>Quantity of this allocation already taken back by sales returns.</summary>
+    public decimal QtyReturned { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/SalesLineSerial.cs b/Backend/ERPCore/Domain/Entities/SalesLineSerial.cs
new file mode 100644
index 0000000..691019d
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/SalesLineSerial.cs
@@ -0,0 +1,29 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A serial chosen on a Draft sales-invoice line for a serial-tracked item — one row per unit
+/// (count = Qty + FreeQty). Choosing does not reserve: posting re-checks each serial is still
+/// in stock and consumes exactly its layer (docs/ITEM_TRACKING_PLAN.md Phase 4, D4).
+/// </summary>
+public class SalesInvoiceLineSerial
+{
+    public int SalesInvoiceLineSerialId { get; set; }
+
+    public int SalesInvoiceLineId { get; set; }
+    public SalesInvoiceLine? SalesInvoiceLine { get; set; }
+
+    public int SerialId { get; set; }
+    public Serial? Serial { get; set; }
+}
+
+/// <summary>Sales-slip counterpart of <see cref="SalesInvoiceLineSerial"/>.</summary>
+public class SalesSlipLineSerial
+{
+    public int SalesSlipLineSerialId { get; set; }
+
+    public int SalesSlipLineId { get; set; }
+    public SalesSlipLine? SalesSlipLine { get; set; }
+
+    public int SerialId { get; set; }
+    public Serial? Serial { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Entities/SalesReturnLine.cs b/Backend/ERPCore/Domain/Entities/SalesReturnLine.cs
index 191adc0..d59214d 100644
--- a/Backend/ERPCore/Domain/Entities/SalesReturnLine.cs
+++ b/Backend/ERPCore/Domain/Entities/SalesReturnLine.cs
@@ -2,7 +2,9 @@ namespace ERPCore.Domain.Entities;
 
 /// <summary>
 /// Sales-return line referencing the original sales invoice line for traceability.
-/// <see cref="Qty"/> is in base UOM.
+/// <see cref="Qty"/> is in base UOM. <see cref="BatchId"/> is the batch the goods are restocked
+/// into — the batch they were sold from (docs/ITEM_TRACKING_PLAN.md Phase 6); <see cref="Serials"/>
+/// lists the returned units of a serial-tracked item.
 /// </summary>
 public class SalesReturnLine
 {
@@ -18,4 +20,21 @@ public class SalesReturnLine
     public Item? Item { get; set; }
 
     public decimal Qty { get; set; }
+
+    public int? BatchId { get; set; }
+    public Batch? Batch { get; set; }
+
+    public ICollection<SalesReturnLineSerial> Serials { get; set; } = new List<SalesReturnLineSerial>();
+}
+
+/// <summary>One serial taken back on a <see cref="SalesReturnLine"/>.</summary>
+public class SalesReturnLineSerial
+{
+    public int SalesReturnLineSerialId { get; set; }
+
+    public int ReturnLineId { get; set; }
+    public SalesReturnLine? ReturnLine { get; set; }
+
+    public int SerialId { get; set; }
+    public Serial? Serial { get; set; }
 }
diff --git a/Backend/ERPCore/Domain/Entities/SalesSlip.cs b/Backend/ERPCore/Domain/Entities/SalesSlip.cs
index c3d713f..eabcda7 100644
--- a/Backend/ERPCore/Domain/Entities/SalesSlip.cs
+++ b/Backend/ERPCore/Domain/Entities/SalesSlip.cs
@@ -27,6 +27,11 @@ public class SalesSlip
     public decimal PaidAmount { get; set; }
     public decimal BalanceAmount { get; set; }
 
+    /// <summary>How <see cref="PaidAmount"/> was tendered: <c>CashAmount + CardAmount == PaidAmount</c>.
+    /// Slips from before the split existed were backfilled as all cash.</summary>
+    public decimal CashAmount { get; set; }
+    public decimal CardAmount { 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; }
diff --git a/Backend/ERPCore/Domain/Entities/SalesSlipLine.cs b/Backend/ERPCore/Domain/Entities/SalesSlipLine.cs
index 5497afe..3570250 100644
--- a/Backend/ERPCore/Domain/Entities/SalesSlipLine.cs
+++ b/Backend/ERPCore/Domain/Entities/SalesSlipLine.cs
@@ -22,9 +22,16 @@ public class SalesSlipLine
     public int? BatchId { get; set; }
     public Batch? Batch { get; set; }
 
+    /// <summary>
+    /// Legacy single-serial pin, from before a line could carry several. Kept for old drafts and
+    /// still set when exactly one serial is chosen; <see cref="Serials"/> is authoritative.
+    /// </summary>
     public int? SerialId { get; set; }
     public Serial? Serial { get; set; }
 
+    /// <summary>Chosen serials for a serial-tracked item (one per unit of Qty + FreeQty).</summary>
+    public ICollection<SalesSlipLineSerial> Serials { get; set; } = new List<SalesSlipLineSerial>();
+
     public decimal UnitPrice { get; set; }
     public decimal BaseCost { get; set; }
     public string PriceSource { get; set; } = string.Empty;
diff --git a/Backend/ERPCore/Domain/Entities/Serial.cs b/Backend/ERPCore/Domain/Entities/Serial.cs
index dbbf7a2..2276703 100644
--- a/Backend/ERPCore/Domain/Entities/Serial.cs
+++ b/Backend/ERPCore/Domain/Entities/Serial.cs
@@ -1,8 +1,13 @@
+using ERPCore.Domain.Enums;
+
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
 /// Serial number for a serial-tracked item across its lifecycle (FR-WH-04).
-/// Model: docs/10 Part C.4.
+/// Created when the GRN that received it is confirmed; each in-stock serial owns exactly one
+/// FIFO layer of qty 1 (<see cref="StockLayer.SerialId"/>), so issuing a serial consumes that
+/// layer. <see cref="WarehouseId"/>/<see cref="BinId"/> are its current location and are
+/// cleared once it leaves stock. Model: docs/10 Part C.4, docs/ITEM_TRACKING_PLAN.md Phase 1.
 /// </summary>
 public class Serial
 {
@@ -12,8 +17,33 @@ public class Serial
     public Item? Item { get; set; }
 
     public string SerialNo { get; set; } = string.Empty;
-    public string Status { get; set; } = "InStock";
+    public SerialStatus Status { get; set; } = SerialStatus.InStock;
 
     /// <summary>Optional scan code for barcode/RFID lookup (unique when set).</summary>
     public string? Barcode { get; set; }
+
+    /// <summary>Current warehouse while in stock; null once sold/returned to vendor/scrapped.</summary>
+    public int? WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public int? BinId { get; set; }
+    public Bin? Bin { get; set; }
+
+    /// <summary>The GRN line that received this unit (provenance); null for count/adjustment finds.</summary>
+    public int? GrnLineId { get; set; }
+    public GrnLine? GrnLine { get; set; }
+
+    public DateTime? ReceivedAt { get; set; }
+
+    /// <summary>
+    /// Warranty coverage snapshotted from <see cref="Item.WarrantyPeriodMonths"/> at receipt
+    /// (same rule as <see cref="GrnLineWarrantyNumber.WarrantyPeriodMonths"/>); null for a
+    /// non-warranty item. The clock does not start here — it starts at sale
+    /// (<see cref="WarrantyRegistration"/>).
+    /// </summary>
+    public int? WarrantyPeriodMonths { get; set; }
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
 }
diff --git a/Backend/ERPCore/Domain/Entities/SerialMovement.cs b/Backend/ERPCore/Domain/Entities/SerialMovement.cs
new file mode 100644
index 0000000..a872c00
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/SerialMovement.cs
@@ -0,0 +1,46 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Append-only history of one serial: a row each time a document changes its status or
+/// location (receipt, sale, return, transfer, adjustment, count). <see cref="Status"/> and
+/// <see cref="WarehouseId"/> are the serial's state <em>after</em> the movement. The source
+/// document is referenced polymorphically, as on <see cref="StockLedger"/>. This is where serial
+/// history is read from — the stock ledger keeps one row per document line, not per unit
+/// (docs/ITEM_TRACKING_PLAN.md Phases 2 and 9).
+/// </summary>
+public class SerialMovement
+{
+    public int SerialMovementId { get; set; }
+
+    public int SerialId { get; set; }
+    public Serial? Serial { get; set; }
+
+    public string SourceDocType { get; set; } = string.Empty;
+    public int SourceDocId { get; set; }
+
+    public SerialStatus Status { get; set; }
+    public int? FromWarehouseId { get; set; }
+    public int? WarehouseId { get; set; }
+
+    public int UserId { get; set; }
+    public DateTime CreatedAt { get; set; }
+
+    /// <summary>
+    /// Records <paramref name="serial"/>'s current state — call after updating it. Linked by
+    /// navigation, so it works for a serial inserted in the same save.
+    /// </summary>
+    public static SerialMovement Of(Serial serial, int? fromWarehouseId, string sourceDocType, int sourceDocId, int userId, DateTime at) => new()
+    {
+        Serial = serial,
+        SerialId = serial.SerialId,
+        SourceDocType = sourceDocType,
+        SourceDocId = sourceDocId,
+        Status = serial.Status,
+        FromWarehouseId = fromWarehouseId,
+        WarehouseId = serial.WarehouseId,
+        UserId = userId,
+        CreatedAt = at
+    };
+}
diff --git a/Backend/ERPCore/Domain/Entities/StockAdjustment.cs b/Backend/ERPCore/Domain/Entities/StockAdjustment.cs
index bcece95..8f72fd1 100644
--- a/Backend/ERPCore/Domain/Entities/StockAdjustment.cs
+++ b/Backend/ERPCore/Domain/Entities/StockAdjustment.cs
@@ -37,5 +37,20 @@ public class StockAdjustment
     public string? GlJournalNo { get; set; }
     public DateTime? GlPostedAt { get; set; }
 
+    // --- Approval (docs/DUAL_APPROVAL_PLAN.md §5). CreatedBy is the requester. ---
+
+    /// <summary>Approvals this request needs (0 = posted on create, 1 or 2), fixed when it is made.</summary>
+    public int RequiredApprovals { get; set; }
+    public int? ApprovedLevel1By { get; set; }
+    public DateTime? ApprovedLevel1At { get; set; }
+    public int? ApprovedLevel2By { get; set; }
+    public DateTime? ApprovedLevel2At { get; set; }
+    public int? RejectedBy { get; set; }
+    public DateTime? RejectedAt { get; set; }
+    public string? RejectReason { get; set; }
+    public DateTime? CancelledAt { get; set; }
+    /// <summary>When stock actually moved — the ledger and GL use this, not <see cref="CreatedAt"/>.</summary>
+    public DateTime? PostedAt { get; set; }
+
     public ICollection<StockAdjustmentLine> Lines { get; set; } = new List<StockAdjustmentLine>();
 }
diff --git a/Backend/ERPCore/Domain/Entities/StockAdjustmentLine.cs b/Backend/ERPCore/Domain/Entities/StockAdjustmentLine.cs
index 8bbc1ad..ecab917 100644
--- a/Backend/ERPCore/Domain/Entities/StockAdjustmentLine.cs
+++ b/Backend/ERPCore/Domain/Entities/StockAdjustmentLine.cs
@@ -18,6 +18,15 @@ public class StockAdjustmentLine
     public int? BinId { get; set; }
     public int? BatchId { get; set; }
     public int? SerialId { get; set; }
+    public Serial? Serial { get; set; }
 
     public decimal QtyDelta { get; set; }
+
+    /// <summary>
+    /// The serials named on the request, kept until it posts (JSON arrays): outbound serial ids
+    /// to write off, inbound serial numbers found. Re-validated at posting, because a pending
+    /// request moves nothing and the serials may have moved in the meantime.
+    /// </summary>
+    public string? RequestedSerialIds { get; set; }
+    public string? RequestedSerialNos { get; set; }
 }
diff --git a/Backend/ERPCore/Domain/Entities/StockTransferLine.cs b/Backend/ERPCore/Domain/Entities/StockTransferLine.cs
index 240d815..c4266a3 100644
--- a/Backend/ERPCore/Domain/Entities/StockTransferLine.cs
+++ b/Backend/ERPCore/Domain/Entities/StockTransferLine.cs
@@ -32,4 +32,27 @@ public class StockTransferLine
 
     /// <summary>Quantity already received at the destination (partial-receive support).</summary>
     public decimal QtyReceived { get; set; }
+
+    /// <summary>The units moved, for a serial-tracked item (one per unit of <see cref="Qty"/>).</summary>
+    public ICollection<StockTransferLineSerial> Serials { get; set; } = new List<StockTransferLineSerial>();
+}
+
+/// <summary>
+/// One serial on a transfer line. <see cref="UnitCost"/>/<see cref="BatchId"/> are captured from
+/// its own source layer at dispatch, so the destination layer is recreated exactly;
+/// <see cref="ReceivedAt"/> is set when it arrives (partial receive names which serials).
+/// </summary>
+public class StockTransferLineSerial
+{
+    public int StockTransferLineSerialId { get; set; }
+
+    public int TransferLineId { get; set; }
+    public StockTransferLine? TransferLine { get; set; }
+
+    public int SerialId { get; set; }
+    public Serial? Serial { get; set; }
+
+    public int? BatchId { get; set; }
+    public decimal? UnitCost { get; set; }
+    public DateTime? ReceivedAt { get; set; }
 }
diff --git a/Backend/ERPCore/Domain/Entities/WarrantyRegistration.cs b/Backend/ERPCore/Domain/Entities/WarrantyRegistration.cs
new file mode 100644
index 0000000..e5c2c3c
--- /dev/null
+++ b/Backend/ERPCore/Domain/Entities/WarrantyRegistration.cs
@@ -0,0 +1,42 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A customer's warranty, started when the sale that issued the goods is posted
+/// (docs/ITEM_TRACKING_PLAN.md Phase 5, D3/D7) — stock waiting in a warehouse never consumes
+/// warranty. For a serial item there is one row per serial (<see cref="SerialId"/> set,
+/// <see cref="Qty"/> = 1); for a warranty item that is not serial-tracked there is one row per
+/// sales line covering its <see cref="Qty"/>. <see cref="PeriodMonths"/> is the coverage
+/// snapshotted at receipt (<see cref="Serial.WarrantyPeriodMonths"/>), else the item's period.
+/// </summary>
+public class WarrantyRegistration
+{
+    public int WarrantyRegistrationId { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public int? SerialId { get; set; }
+    public Serial? Serial { get; set; }
+
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+
+    public string SourceDocType { get; set; } = string.Empty;
+    public int SourceDocId { get; set; }
+    public int SourceLineId { get; set; }
+
+    public decimal Qty { get; set; }
+
+    public DateOnly StartDate { get; set; }
+    public int PeriodMonths { get; set; }
+    public DateOnly EndDate { get; set; }
+
+    public WarrantyStatus Status { get; set; } = WarrantyStatus.Active;
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+}
diff --git a/Backend/ERPCore/Domain/Enums/AdjustmentStatus.cs b/Backend/ERPCore/Domain/Enums/AdjustmentStatus.cs
index 7d56708..1301e79 100644
--- a/Backend/ERPCore/Domain/Enums/AdjustmentStatus.cs
+++ b/Backend/ERPCore/Domain/Enums/AdjustmentStatus.cs
@@ -1,13 +1,33 @@
 namespace ERPCore.Domain.Enums;
 
 /// <summary>
-/// Stock-adjustment lifecycle (docs/10 §B.8.1). Phase 1 auto-posts, so
-/// <see cref="PendingApproval"/> is reserved for the future threshold-approval
-/// workflow (FR-STK-07). Stored as a string.
+/// Stock-adjustment lifecycle (docs/DUAL_APPROVAL_PLAN.md §5.1). A new adjustment is a request
+/// (<see cref="PendingApproval"/>, then <see cref="PendingSecondApproval"/> when two approvals are
+/// required) and only moves stock when it becomes <see cref="Posted"/>. With approvals switched off
+/// (<c>ApprovalConfig.StockAdjustmentLevels = 0</c>) it posts on create, as before. Stored as a string.
 /// </summary>
 public enum AdjustmentStatus
 {
     Draft,
     PendingApproval,
-    Posted
+    Posted,
+    PendingSecondApproval,
+    Rejected,
+    Cancelled
+}
+
+/// <summary>Price-adjustment lifecycle — same request flow as <see cref="AdjustmentStatus"/>; <see cref="Approved"/> means applied.</summary>
+public enum PriceAdjustmentStatus
+{
+    PendingApproval,
+    PendingSecondApproval,
+    Approved,
+    Rejected,
+    Cancelled
+}
+
+public enum ApprovalDecision
+{
+    Approved,
+    Rejected
 }
diff --git a/Backend/ERPCore/Domain/Enums/BankDepositStatus.cs b/Backend/ERPCore/Domain/Enums/BankDepositStatus.cs
new file mode 100644
index 0000000..1e530f0
--- /dev/null
+++ b/Backend/ERPCore/Domain/Enums/BankDepositStatus.cs
@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>A deposit is posted as soon as it is saved; a wrong one is cancelled (GL reversed) and re-entered.</summary>
+public enum BankDepositStatus
+{
+    Posted,
+    Cancelled
+}
diff --git a/Backend/ERPCore/Domain/Enums/ExpenseStatus.cs b/Backend/ERPCore/Domain/Enums/ExpenseStatus.cs
new file mode 100644
index 0000000..6dc3236
--- /dev/null
+++ b/Backend/ERPCore/Domain/Enums/ExpenseStatus.cs
@@ -0,0 +1,24 @@
+namespace ERPCore.Domain.Enums;
+
+public enum ExpenseStatus
+{
+    Draft,
+    Posted,
+    Cancelled
+}
+
+/// <summary>Settlement state of a Posted expense, derived from its paid/balance amounts.</summary>
+public enum ExpensePaymentStatus
+{
+    Unpaid,
+    PartiallyPaid,
+    Paid
+}
+
+public enum ExpensePaymentMethod
+{
+    Cash,
+    BankTransfer,
+    Cheque,
+    Card
+}
diff --git a/Backend/ERPCore/Domain/Enums/SalesPaymentMethod.cs b/Backend/ERPCore/Domain/Enums/SalesPaymentMethod.cs
new file mode 100644
index 0000000..43f461b
--- /dev/null
+++ b/Backend/ERPCore/Domain/Enums/SalesPaymentMethod.cs
@@ -0,0 +1,12 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>How a customer paid for a sale — recorded per invoice payment (and split into
+/// cash/card amounts on slips and bundle sales) so the Day-End Sales Report can break
+/// collections down by method. Mirrors <see cref="ExpensePaymentMethod"/>.</summary>
+public enum SalesPaymentMethod
+{
+    Cash,
+    Card,
+    BankTransfer,
+    Cheque
+}
diff --git a/Backend/ERPCore/Domain/Enums/SerialStatus.cs b/Backend/ERPCore/Domain/Enums/SerialStatus.cs
new file mode 100644
index 0000000..32c43db
--- /dev/null
+++ b/Backend/ERPCore/Domain/Enums/SerialStatus.cs
@@ -0,0 +1,25 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Lifecycle state of one serial-tracked unit (FR-WH-04). Stored as a string — the values
+/// <c>InStock</c>/<c>Sold</c> written before this enum existed stay valid as-is.
+/// Only <see cref="InStock"/> is issuable.
+/// </summary>
+public enum SerialStatus
+{
+    InStock,
+    Reserved,
+    /// <summary>Dispatched on a stock transfer, not yet received — in no warehouse.</summary>
+    InTransit,
+    Sold,
+    ReturnedByCustomer,
+    ReturnedToVendor,
+    Damaged,
+    Scrapped,
+    /// <summary>
+    /// Left stock without being named, while serial numbers were switched off in Product
+    /// Configuration — the unit was issued oldest-first like untracked stock, so which
+    /// document took it is not recorded against the serial.
+    /// </summary>
+    IssuedUntracked
+}
diff --git a/Backend/ERPCore/Domain/Enums/WarrantyStatus.cs b/Backend/ERPCore/Domain/Enums/WarrantyStatus.cs
new file mode 100644
index 0000000..ab53b54
--- /dev/null
+++ b/Backend/ERPCore/Domain/Enums/WarrantyStatus.cs
@@ -0,0 +1,10 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>State of a <see cref="Entities.WarrantyRegistration"/>. Stored as a string.</summary>
+public enum WarrantyStatus
+{
+    Active,
+    /// <summary>The unit came back on a sales return — the warranty no longer applies.</summary>
+    Voided,
+    Claimed
+}
diff --git a/Backend/ERPCore/Domain/Notifications/Modules/NotificationModules.cs b/Backend/ERPCore/Domain/Notifications/Modules/NotificationModules.cs
index 49c4efb..831df17 100644
--- a/Backend/ERPCore/Domain/Notifications/Modules/NotificationModules.cs
+++ b/Backend/ERPCore/Domain/Notifications/Modules/NotificationModules.cs
@@ -27,6 +27,18 @@ public sealed class StockAdjustmentCreatedNotificationModule;
 [NotificationModule("stock.transfer.created", "Stock Transfer Created", "Raised when a stock transfer is created.", 90)]
 public sealed class StockTransferCreatedNotificationModule;
 
+[NotificationModule("stock.low", "Low Stock / Reorder Alert", "Raised when a sale, transfer or adjustment takes an item's stock at a warehouse to or below its reorder point.", 95)]
+public sealed class StockLowNotificationModule;
+
+[NotificationModule("approval.pending", "Approval Needed", "Sent to the people who can approve a stock or price adjustment that is waiting for them.", 96)]
+public sealed class ApprovalPendingNotificationModule;
+
+[NotificationModule("approval.approved", "Request Approved", "Sent to the requester when their stock or price adjustment is fully approved and applied.", 97)]
+public sealed class ApprovalApprovedNotificationModule;
+
+[NotificationModule("approval.rejected", "Request Rejected", "Sent to the requester when their stock or price adjustment is rejected.", 98)]
+public sealed class ApprovalRejectedNotificationModule;
+
 [NotificationModule("item.created", "Item Created", "Raised when an item master record is created.", 100)]
 public sealed class ItemCreatedNotificationModule;
 
diff --git a/Backend/ERPCore/Dtos/Accounts/BankDepositDtos.cs b/Backend/ERPCore/Dtos/Accounts/BankDepositDtos.cs
new file mode 100644
index 0000000..25d86b0
--- /dev/null
+++ b/Backend/ERPCore/Dtos/Accounts/BankDepositDtos.cs
@@ -0,0 +1,66 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+
+namespace ERPCore.Dtos.Accounts;
+
+// --- Cash in hand (docs/BANK_DEPOSIT_MODULE_PLAN.md §2, §7.1) ---
+
+/// <summary>
+/// One business day's till cash. CashIn is slip/bundle cash plus cash invoice payments received
+/// that day; CashOut is expense payments made in cash; Deposited is Posted bank deposits for that
+/// business day. Closing = Opening + NetCash − Deposited, and becomes the next day's Opening.
+/// Days before the tracking start date carry nothing in: their Opening is 0.
+/// </summary>
+public sealed record CashPositionDto(
+    DateOnly Date, decimal Opening, decimal CashIn, decimal CashOut, decimal NetCash, decimal Deposited, decimal Closing);
+
+/// <summary>
+/// A day's cash position for the deposit form. <paramref name="AvailableToDeposit"/> is the lowest
+/// closing balance from that day up to today: a back-dated deposit lowers every later day too.
+/// <paramref name="DefaultCashAccountCode"/> is the GL cash account the form preselects.
+/// </summary>
+public sealed record CashInHandDto(
+    CashPositionDto Position, decimal AvailableToDeposit, int? BranchId, DateOnly? TrackingStartDate, string TimeZone,
+    string? DefaultCashAccountCode);
+
+public sealed record CashInHandDailyDto(
+    DateOnly From, DateOnly To, IReadOnlyList<CashPositionDto> Days, int? BranchId, DateOnly? TrackingStartDate, string TimeZone);
+
+// --- Deposits ---
+
+public sealed record BankDepositDto(
+    int BankDepositId, string DocNo, int BranchId, string? BranchName,
+    DateOnly BusinessDate, DateOnly DepositDate, decimal Amount,
+    long FromGlCashAccountId, string FromCashAccountCode, string FromCashAccountName,
+    long ToGlBankAccountId, string ToBankAccountCode, string ToBankAccountName, string? ToBankName, string? ToAccountNumber,
+    string? DepositSlipNo, string? DepositedBy, string? Remarks,
+    BankDepositStatus Status, string? GlJournalNo, DateTime? GlPostedAt,
+    string? GlReversalJournalNo, string? CancelReason, DateTime? CancelledAt,
+    int CreatedBy, DateTime CreatedAt);
+
+/// <summary>A page of deposits plus the total amount of every row matching the filter (not just this page).</summary>
+public sealed record BankDepositListDto(IReadOnlyList<BankDepositDto> Items, PaginationDto Pagination, decimal TotalAmount);
+
+public sealed record BankDepositListFilter(
+    DateOnly? From, DateOnly? To, int? BranchId, long? BankAccountId, BankDepositStatus? Status);
+
+public sealed class CreateBankDepositRequest
+{
+    /// <summary>Required when branching is enabled; otherwise the default branch is used. A branch user always deposits for their own branch.</summary>
+    public int BranchId { get; set; }
+    [Required] public DateOnly BusinessDate { get; set; }
+    /// <summary>When the bank received it; also the GL entry date. Omitted ⇒ the business date.</summary>
+    public DateOnly? DepositDate { get; set; }
+    [Range(0.01, 999_999_999_999)] public decimal Amount { get; set; }
+    [Required] public long FromGlCashAccountId { get; set; }
+    [Required] public long ToGlBankAccountId { get; set; }
+    [StringLength(50)] public string? DepositSlipNo { get; set; }
+    [StringLength(150)] public string? DepositedBy { get; set; }
+    [StringLength(500)] public string? Remarks { get; set; }
+}
+
+public sealed class CancelBankDepositRequest
+{
+    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
+}
diff --git a/Backend/ERPCore/Dtos/Approvals/ApprovalDtos.cs b/Backend/ERPCore/Dtos/Approvals/ApprovalDtos.cs
new file mode 100644
index 0000000..94eaf00
--- /dev/null
+++ b/Backend/ERPCore/Dtos/Approvals/ApprovalDtos.cs
@@ -0,0 +1,43 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Approvals;
+
+/// <summary>One decision in a document's approval trail.</summary>
+public sealed record ApprovalStepDto(int Level, ApprovalDecision Decision, int DecidedBy, string? DecidedByName, DateTime DecidedAt, string? Comment);
+
+/// <summary>Settings → Approvals (docs/DUAL_APPROVAL_PLAN.md §7).</summary>
+public sealed record ApprovalConfigDto(
+    int StockAdjustmentLevels, decimal StockAdjustmentLevel2ThresholdValue,
+    int PriceAdjustmentLevels, decimal PriceAdjustmentLevel2ThresholdPercent,
+    IReadOnlyList<string> Level2RoleCodes, DateTime? UpdatedAt);
+
+public sealed class UpdateApprovalConfigRequest
+{
+    [Range(0, 2)] public int StockAdjustmentLevels { get; set; }
+    [Range(0, double.MaxValue)] public decimal StockAdjustmentLevel2ThresholdValue { get; set; }
+    [Range(0, 2)] public int PriceAdjustmentLevels { get; set; }
+    [Range(0, 1000)] public decimal PriceAdjustmentLevel2ThresholdPercent { get; set; }
+    public List<string> Level2RoleCodes { get; set; } = new();
+}
+
+public sealed class ApproveRequest
+{
+    [StringLength(250)] public string? Comment { get; set; }
+}
+
+public sealed class RejectRequest
+{
+    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
+}
+
+/// <summary>
+/// A request waiting in the Approvals inbox. <paramref name="Level"/> is the approval it waits for
+/// (1 or 2) of <paramref name="RequiredApprovals"/>; <paramref name="CanApprove"/> says whether the
+/// current user may decide it (not the requester, not the level-1 approver, has the right role).
+/// </summary>
+public sealed record PendingApprovalDto(
+    string DocType, int DocId, string DocNo, string Summary, int Level, int RequiredApprovals,
+    int RequestedBy, string? RequestedByName, DateTime RequestedAt, bool CanApprove, string? WhyNot);
+
+public sealed record PendingApprovalsDto(IReadOnlyList<PendingApprovalDto> Items, int ActionableCount);
diff --git a/Backend/ERPCore/Dtos/Customers/CustomerDtos.cs b/Backend/ERPCore/Dtos/Customers/CustomerDtos.cs
index 8176c60..473093b 100644
--- a/Backend/ERPCore/Dtos/Customers/CustomerDtos.cs
+++ b/Backend/ERPCore/Dtos/Customers/CustomerDtos.cs
@@ -4,6 +4,9 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Dtos.Customers;
 
 /// <summary>Customer resource used by sales documents.</summary>
+/// <param name="OutstandingAmount">Unpaid balance across the customer's Posted sales invoices. Filled on the list only.</param>
+/// <param name="OutstandingInvoiceCount">Posted sales invoices with a balance still due. Filled on the list only.</param>
+/// <param name="LastPaymentDate">When the customer last paid against an invoice; null if never. Filled on the list only.</param>
 public sealed record CustomerDto(
     int CustomerId,
     string CustomerCode,
@@ -23,7 +26,10 @@ public sealed record CustomerDto(
     EntityStatus Status,
     int BranchId,
     DateTime CreatedAt,
-    DateTime? UpdatedAt);
+    DateTime? UpdatedAt,
+    decimal OutstandingAmount = 0m,
+    int OutstandingInvoiceCount = 0,
+    DateTime? LastPaymentDate = null);
 
 public sealed class CreateCustomerRequest
 {
diff --git a/Backend/ERPCore/Dtos/Expenses/ExpenseDtos.cs b/Backend/ERPCore/Dtos/Expenses/ExpenseDtos.cs
new file mode 100644
index 0000000..8d756f4
--- /dev/null
+++ b/Backend/ERPCore/Dtos/Expenses/ExpenseDtos.cs
@@ -0,0 +1,120 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Expenses;
+
+// --- Setup: categories and titles (docs/EXPENSE_MODULE_PLAN.md §6 "Setup") ---
+
+public sealed record ExpenseTitleDto(
+    int ExpenseTitleId, int ExpenseCategoryId, string Name, string GlExpenseAccountCode,
+    bool IsSystem, EntityStatus Status, int SortOrder);
+
+public sealed record ExpenseCategoryDto(
+    int ExpenseCategoryId, string Code, string Name, bool IsSystem, EntityStatus Status, int SortOrder,
+    IReadOnlyList<ExpenseTitleDto> Titles);
+
+public sealed class UpdateExpenseCategoryRequest
+{
+    /// <summary>Ignored-if-unchanged for system rows; a different name on a system row is rejected.</summary>
+    [Required, StringLength(100, MinimumLength = 1)] public string Name { get; set; } = string.Empty;
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+}
+
+public sealed class CreateExpenseTitleRequest
+{
+    [Required, StringLength(100, MinimumLength = 1)] public string Name { get; set; } = string.Empty;
+    [Required, StringLength(20, MinimumLength = 1)] public string GlExpenseAccountCode { get; set; } = string.Empty;
+}
+
+public sealed class UpdateExpenseTitleRequest
+{
+    /// <summary>Ignored-if-unchanged for system rows; a different name on a system row is rejected.</summary>
+    [Required, StringLength(100, MinimumLength = 1)] public string Name { get; set; } = string.Empty;
+    [Required, StringLength(20, MinimumLength = 1)] public string GlExpenseAccountCode { get; set; } = string.Empty;
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+}
+
+// --- Expenses ---
+
+public sealed record ExpenseSummaryDto(
+    int ExpenseId, string DocNo, int BranchId, DateOnly ExpenseDate, DateOnly? DueDate,
+    int ExpenseCategoryId, string CategoryName, int ExpenseTitleId, string TitleName,
+    string? Payee, string? BillReference, string? PeriodMonth,
+    decimal Amount, decimal PaidAmount, decimal BalanceAmount,
+    ExpenseStatus Status, ExpensePaymentStatus PaymentStatus, string? GlJournalNo, DateTime CreatedAt);
+
+public sealed record ExpensePaymentDto(
+    int ExpensePaymentId, int ExpenseId, decimal Amount, DateTime PaymentDate, ExpensePaymentMethod PaymentMethod,
+    long GlBankAccountId, string BankAccountName, string? ChequeNo, string? Reference, string? GlJournalNo, DateTime CreatedAt);
+
+public sealed record ExpenseDto(
+    int ExpenseId, string DocNo, int BranchId, DateOnly ExpenseDate, DateOnly? DueDate,
+    int ExpenseCategoryId, string CategoryName, int ExpenseTitleId, string TitleName,
+    string? Payee, int? VendorId, string? VendorName, string? BillReference, string? Description, string? PeriodMonth,
+    decimal Amount, decimal PaidAmount, decimal BalanceAmount,
+    ExpenseStatus Status, ExpensePaymentStatus PaymentStatus,
+    string? GlExpenseAccountCode, string? GlJournalNo, DateTime? GlPostedAt, string? GlReversalJournalNo, string? CancelReason,
+    int CreatedBy, DateTime CreatedAt, DateTime? UpdatedAt,
+    IReadOnlyList<ExpensePaymentDto> Payments);
+
+public class ExpenseRequestBase
+{
+    /// <summary>Required when branching is enabled; otherwise the default branch is used.</summary>
+    public int BranchId { get; set; }
+    [Required] public DateOnly ExpenseDate { get; set; }
+    public DateOnly? DueDate { get; set; }
+    [Required] public int ExpenseCategoryId { get; set; }
+    [Required] public int ExpenseTitleId { get; set; }
+    [StringLength(150)] public string? Payee { get; set; }
+    public int? VendorId { get; set; }
+    [StringLength(50)] public string? BillReference { get; set; }
+    [StringLength(500)] public string? Description { get; set; }
+    [RegularExpression(@"^\d{4}-(0[1-9]|1[0-2])$", ErrorMessage = "PeriodMonth must be yyyy-MM.")]
+    public string? PeriodMonth { get; set; }
+    [Range(0.01, 999_999_999_999)] public decimal Amount { get; set; }
+}
+
+public sealed class CreateExpenseRequest : ExpenseRequestBase;
+
+public sealed class UpdateExpenseRequest : ExpenseRequestBase;
+
+public sealed class CancelExpenseRequest
+{
+    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
+}
+
+public sealed class ExpensePaymentLineRequest
+{
+    [Required] public long GlBankAccountId { get; set; }
+    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
+}
+
+/// <summary>
+/// One payment submission: one or more lines (e.g. part cash, part bank), all posted in a
+/// single GL journal entry. Total must not exceed the balance (for Post &amp; Pay, the amount); partial is fine.
+/// </summary>
+public sealed class CreateExpensePaymentRequest
+{
+    [Required, MinLength(1)] public List<ExpensePaymentLineRequest> Lines { get; set; } = new();
+    public ExpensePaymentMethod PaymentMethod { get; set; } = ExpensePaymentMethod.Cash;
+    /// <summary>Required when <see cref="PaymentMethod"/> is Cheque.</summary>
+    [StringLength(30)] public string? ChequeNo { get; set; }
+    [StringLength(100)] public string? Reference { get; set; }
+    /// <summary>When it was paid; also the GL entry date. Omitted ⇒ today. Never in the future.</summary>
+    public DateOnly? PaymentDate { get; set; }
+}
+
+public sealed record ExpenseListFilter(
+    ExpenseStatus? Status, ExpensePaymentStatus? PaymentStatus, int? CategoryId, int? TitleId,
+    DateOnly? From, DateOnly? To, bool OverdueOnly);
+
+public sealed record ExpenseTitleTotalDto(int ExpenseTitleId, string TitleName, decimal Amount, int Count);
+
+public sealed record ExpenseCategoryTotalDto(
+    int ExpenseCategoryId, string CategoryName, decimal Amount, int Count, IReadOnlyList<ExpenseTitleTotalDto> Titles);
+
+/// <summary>Posted (non-cancelled) expenses dated within [From, To], plus the all-time unpaid/overdue position.</summary>
+public sealed record ExpenseSummaryReportDto(
+    DateOnly From, DateOnly To, decimal TotalAmount, decimal PaidAmount, decimal UnpaidAmount, int Count,
+    decimal OutstandingAmount, decimal OverdueAmount, int OverdueCount, int DraftCount,
+    IReadOnlyList<ExpenseCategoryTotalDto> Categories);
diff --git a/Backend/ERPCore/Dtos/Grn/GrnDtos.cs b/Backend/ERPCore/Dtos/Grn/GrnDtos.cs
index 84b47cd..9fad1dc 100644
--- a/Backend/ERPCore/Dtos/Grn/GrnDtos.cs
+++ b/Backend/ERPCore/Dtos/Grn/GrnDtos.cs
@@ -7,12 +7,16 @@ namespace ERPCore.Dtos.Grn;
 
 public sealed record GrnLineWarrantyNumberDto(string WarrantyNo, int WarrantyPeriodMonths);
 
+/// <summary>A serial captured on a GRN line; <see cref="SerialId"/> is set once the GRN is confirmed.</summary>
+public sealed record GrnLineSerialDto(string SerialNo, int? SerialId);
+
 public sealed record GrnLineDto(
     int GrnLineId, int? PoLineId, int ItemId, 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, IReadOnlyList<GrnLineWarrantyNumberDto> WarrantyNumbers,
+    string? BatchNo, DateOnly? BatchExpiryDate, IReadOnlyList<GrnLineSerialDto> Serials);
 
 public sealed record GrnDto(
     int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, int BranchId, GrnStatus Status,
@@ -70,9 +74,15 @@ public sealed class CreateGrnLineInput
     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.
+    /// warranty-tracked (<c>Item.Warranty == Warranty.Warranty</c>) and not serial-tracked —
+    /// a serial item's serial is its warranty identity. Ignored otherwise.
     /// </summary>
     public List<string>? WarrantyNumbers { get; set; }
+    /// <summary>
+    /// Required, one per unit (count must equal <see cref="Qty"/>, so Qty must be whole), when the
+    /// item is serial-tracked (<c>Item.TrackingMode == Serial</c>). Rejected for any other item.
+    /// </summary>
+    public List<string>? SerialNumbers { get; set; }
 }
 
 public sealed class CreateGrnRequest
diff --git a/Backend/ERPCore/Dtos/Items/ItemOverviewDtos.cs b/Backend/ERPCore/Dtos/Items/ItemOverviewDtos.cs
index 438ef01..164a11b 100644
--- a/Backend/ERPCore/Dtos/Items/ItemOverviewDtos.cs
+++ b/Backend/ERPCore/Dtos/Items/ItemOverviewDtos.cs
@@ -2,6 +2,14 @@ using ERPCore.Domain.Enums;
 
 namespace ERPCore.Dtos.Items;
 
+/// <summary>
+/// One posted GRN receipt of an item — what it was bought at. <paramref name="NetUnitCost"/> is the
+/// cost after trade discount (the FIFO stock cost, VAT excluded) — the figure to price against.
+/// </summary>
+public sealed record ItemPurchasePriceDto(
+    int GrnId, string GrnDocNo, DateTime ReceivedAt, int VendorId, string? VendorName, string? WarehouseCode,
+    decimal Qty, decimal UnitCost, decimal DiscountPct, decimal NetUnitCost, decimal VatPct);
+
 /// <summary>
 /// Item row enriched with cross-module aggregates (current FIFO stock value, low-stock
 /// flag, last purchase, trailing-30-day sales) for the Items list page. Deliberately a
diff --git a/Backend/ERPCore/Dtos/Procurement/PurchaseInvoiceDtos.cs b/Backend/ERPCore/Dtos/Procurement/PurchaseInvoiceDtos.cs
index 483b8db..69e293e 100644
--- a/Backend/ERPCore/Dtos/Procurement/PurchaseInvoiceDtos.cs
+++ b/Backend/ERPCore/Dtos/Procurement/PurchaseInvoiceDtos.cs
@@ -31,6 +31,8 @@ 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; }
+    /// <summary>When the vendor was paid; also the GL entry date. Omitted ⇒ today. Never in the future.</summary>
+    public DateOnly? PaymentDate { get; set; }
 }
 
 public sealed class CreatePurchaseInvoiceRequest
diff --git a/Backend/ERPCore/Dtos/Procurement/PurchaseReturnDtos.cs b/Backend/ERPCore/Dtos/Procurement/PurchaseReturnDtos.cs
index d6fc74a..b8591c8 100644
--- a/Backend/ERPCore/Dtos/Procurement/PurchaseReturnDtos.cs
+++ b/Backend/ERPCore/Dtos/Procurement/PurchaseReturnDtos.cs
@@ -25,6 +25,12 @@ public sealed class CreatePurchaseReturnLineInput
     public int? GrnLineId { get; set; }
     [Required] public int ItemId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    /// <summary>
+    /// Serials sent back, for a serial-tracked item — one per unit, each at the return warehouse
+    /// (InStock or Damaged; for a rejected GRN line, received on that line). They become
+    /// <c>ReturnedToVendor</c>. Rejected for any other item.
+    /// </summary>
+    public List<int>? SerialIds { get; set; }
 }
 
 public sealed class CreatePurchaseReturnRequest
diff --git a/Backend/ERPCore/Dtos/Products/PriceAdjustmentDtos.cs b/Backend/ERPCore/Dtos/Products/PriceAdjustmentDtos.cs
new file mode 100644
index 0000000..99c1b28
--- /dev/null
+++ b/Backend/ERPCore/Dtos/Products/PriceAdjustmentDtos.cs
@@ -0,0 +1,47 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Approvals;
+
+namespace ERPCore.Dtos.Products;
+
+/// <summary>One item's requested change. Current* are the item's prices now — they differ from Old* when it was repriced since.</summary>
+public sealed record PriceAdjustmentLineDto(
+    int PriceAdjustmentLineId, int ItemId, string Sku, string ItemName,
+    decimal? OldMinPrice, decimal? OldMaxPrice, decimal? OldFlatPrice,
+    decimal? NewMinPrice, decimal? NewMaxPrice, decimal? NewFlatPrice,
+    decimal? CurrentMinPrice, decimal? CurrentMaxPrice, decimal? CurrentFlatPrice);
+
+public sealed record PriceAdjustmentSummaryDto(
+    int PriceAdjustmentId, string DocNo, string Reason, PriceAdjustmentStatus Status, int RequiredApprovals, int? PendingLevel,
+    int LineCount, int CreatedBy, string? CreatedByName, DateTime CreatedAt, DateTime? AppliedAt);
+
+/// <param name="PendingLevel">The approval it waits for (1 or 2); null once decided.</param>
+public sealed record PriceAdjustmentDto(
+    int PriceAdjustmentId, string DocNo, string Reason, PriceAdjustmentStatus Status, int RequiredApprovals, int? PendingLevel,
+    int CreatedBy, string? CreatedByName, DateTime CreatedAt,
+    int? ApprovedLevel1By, DateTime? ApprovedLevel1At, int? ApprovedLevel2By, DateTime? ApprovedLevel2At,
+    int? RejectedBy, DateTime? RejectedAt, string? RejectReason, DateTime? CancelledAt, DateTime? AppliedAt,
+    IReadOnlyList<PriceAdjustmentLineDto> Lines, IReadOnlyList<ApprovalStepDto> ApprovalHistory, bool CanApprove, string? WhyNot,
+    bool CanWithdraw);
+
+public sealed class PriceAdjustmentLineInput
+{
+    [Required] public int ItemId { get; set; }
+    /// <summary>The prices the item should have afterwards — null clears that price.</summary>
+    [Range(0, double.MaxValue)] public decimal? NewMinPrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? NewMaxPrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? NewFlatPrice { get; set; }
+}
+
+public sealed class CreatePriceAdjustmentRequest
+{
+    [Required, StringLength(250, MinimumLength = 1)] public string Reason { get; set; } = string.Empty;
+    [Required, MinLength(1)] public List<PriceAdjustmentLineInput> Lines { get; set; } = new();
+}
+
+public sealed record ItemPriceHistoryDto(
+    int ItemPriceHistoryId, int ItemId, int? PriceAdjustmentId, string? DocNo,
+    decimal? OldMinPrice, decimal? OldMaxPrice, decimal? OldFlatPrice,
+    decimal? NewMinPrice, decimal? NewMaxPrice, decimal? NewFlatPrice,
+    int RequestedBy, string? RequestedByName, int? ApprovedLevel1By, string? ApprovedLevel1ByName,
+    int? ApprovedLevel2By, string? ApprovedLevel2ByName, DateTime AppliedAt);
diff --git a/Backend/ERPCore/Dtos/Reports/DayEndReportDtos.cs b/Backend/ERPCore/Dtos/Reports/DayEndReportDtos.cs
new file mode 100644
index 0000000..5a13c14
--- /dev/null
+++ b/Backend/ERPCore/Dtos/Reports/DayEndReportDtos.cs
@@ -0,0 +1,51 @@
+namespace ERPCore.Dtos.Reports;
+
+/// <summary>
+/// One business day's figures (or, with <see cref="Date"/> null, a range's totals) — docs/DAY_END_SALES_REPORT_PLAN.md §4.
+/// Sales are Posted slips, bundle sales and invoices dated that day; Paid is what has been paid on
+/// those sales so far (split by how it was paid) and Due the rest.
+/// </summary>
+/// <param name="Income">TotalSales − ExpenseTotal (sales returns aren't priced, so they can't be netted off).</param>
+/// <param name="CostOfGoodsSold">FIFO cost of the stock those sales issued (the stock ledger's Out value).</param>
+/// <param name="GrossProfit">TotalSales − CostOfGoodsSold.</param>
+/// <param name="NetProfit">GrossProfit − ExpenseTotal; negative is a loss.</param>
+/// <param name="EarlierInvoiceCollections">Invoice payments received this day against invoices from
+/// earlier days — not part of PaidAmount.</param>
+/// <param name="NetCash">Cash that came in this day (slip/bundle cash + cash invoice payments, any
+/// invoice) minus expenses paid in cash this day — a till check.</param>
+/// <param name="OpeningCashInHand">Cash left in the till from earlier days (docs/BANK_DEPOSIT_MODULE_PLAN.md §9).
+/// For a range's totals, the first day's opening.</param>
+/// <param name="CashDeposited">Posted bank deposits made against this business day.</param>
+/// <param name="ClosingCashInHand">Opening + NetCash − CashDeposited: cash still in hand. For a range's totals, the last day's closing.</param>
+public sealed record DayEndReportDayDto(
+    DateOnly? Date,
+    decimal TotalSales, decimal PaidAmount, decimal DueAmount,
+    decimal PaidByCash, decimal PaidByCard, decimal PaidByOther,
+    int SalesCount, int CashSalesCount, int CardSalesCount, int MixedSalesCount, int OtherSalesCount, int UnpaidSalesCount,
+    decimal ExpenseTotal, decimal Income,
+    decimal CostOfGoodsSold, decimal GrossProfit, decimal NetProfit,
+    decimal EarlierInvoiceCollections,
+    decimal NetCash,
+    decimal OpeningCashInHand, decimal CashDeposited, decimal ClosingCashInHand);
+
+/// <summary>One sale of the day. <paramref name="PaidBy"/> is Cash, Card, Bank transfer, Cheque, Mixed or Unpaid.</summary>
+public sealed record DayEndReportSaleDto(
+    string DocType, int DocId, string DocNo, DateTime At, string CustomerName,
+    decimal Total, decimal Paid, decimal Due, string PaidBy, decimal Cost, decimal GrossProfit);
+
+public sealed record DayEndReportExpenseDto(
+    int ExpenseId, string DocNo, string CategoryName, string TitleName, string? Payee, decimal Amount, decimal PaidAmount);
+
+/// <summary>A Posted bank deposit of this business day's cash.</summary>
+public sealed record DayEndReportDepositDto(
+    int BankDepositId, string DocNo, string BankAccountName, string? BankName, string? AccountNumber,
+    string? DepositSlipNo, DateOnly DepositDate, decimal Amount);
+
+/// <summary>A single day: its figures plus the sales, expenses and bank deposits behind them.</summary>
+public sealed record DayEndReportDto(
+    DayEndReportDayDto Summary, IReadOnlyList<DayEndReportSaleDto> Sales, IReadOnlyList<DayEndReportExpenseDto> Expenses,
+    IReadOnlyList<DayEndReportDepositDto> Deposits, int? BranchId, string TimeZone);
+
+/// <summary>Day-wise figures for a range (every day present, zeros on quiet days) plus the range's totals.</summary>
+public sealed record DayEndDailyReportDto(
+    DateOnly From, DateOnly To, IReadOnlyList<DayEndReportDayDto> Days, DayEndReportDayDto Totals, int? BranchId, string TimeZone);
diff --git a/Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs b/Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs
index 9ab6b6b..80a6e19 100644
--- a/Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs
+++ b/Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs
@@ -12,7 +12,7 @@ public sealed record BundleSaleDto(
     int WarehouseId, int CashierUserId, int BundleSaleTemplateId, string BundleName, string BundleCode,
     BundleSaleStatus Status, decimal ComponentSubtotal, decimal BundlePrice, decimal MarginAmount,
     decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal, DateTime CreatedAt, DateTime? UpdatedAt,
-    IReadOnlyList<BundleSaleLineDto> Lines);
+    IReadOnlyList<BundleSaleLineDto> Lines, decimal CashAmount, decimal CardAmount);
 
 public sealed record BundleSaleSummaryDto(
     int BundleSaleId, string BundleNo, DateTime BundleDate, int CustomerId, string CustomerSnapshotName,
@@ -66,6 +66,8 @@ public sealed class CreateBundleSaleRequest
     [Range(0, double.MaxValue)] public decimal BundlePrice { get; set; }
     public bool AllowPriceOverride { get; set; }
     [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
+    /// <summary>The part of the total tendered by card; the rest is cash. Omit for all cash.</summary>
+    [Range(0, double.MaxValue)] public decimal? CardAmount { get; set; }
 }
 
 public sealed class UpdateBundleSaleRequest
@@ -78,4 +80,6 @@ public sealed class UpdateBundleSaleRequest
     [Range(0, double.MaxValue)] public decimal BundlePrice { get; set; }
     public bool AllowPriceOverride { get; set; }
     [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
+    /// <summary>See <see cref="CreateBundleSaleRequest.CardAmount"/>.</summary>
+    [Range(0, double.MaxValue)] public decimal? CardAmount { get; set; }
 }
diff --git a/Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs b/Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs
index 302b04f..77cd30d 100644
--- a/Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs
+++ b/Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs
@@ -7,7 +7,11 @@ public sealed record SalesInvoiceLineDto(
     int SalesInvoiceLineId, int ItemId, string Description, decimal Qty, decimal FreeQty,
     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);
+    decimal TaxPct, decimal TaxAmount, bool IsFreeIssue, int? ParentLineId,
+    int? BatchId, IReadOnlyList<SalesLineSerialDto> Serials);
+
+/// <summary>A serial chosen on (or sold by) a sales line.</summary>
+public sealed record SalesLineSerialDto(int SerialId, string SerialNo);
 
 public sealed record SalesInvoiceTotalsDto(
     decimal Subtotal, decimal DiscountTotal, decimal FreeQtyTotal, decimal TaxTotal, decimal GrandTotal,
@@ -27,12 +31,15 @@ public sealed record SalesInvoiceSummaryDto(
 
 public sealed record SalesInvoicePaymentDto(
     int SalesInvoicePaymentId, int SalesInvoiceId, decimal Amount, DateTime PaymentDate,
-    long GlBankAccountId, string BankAccountName, string? Reference, string? GlJournalNo, DateTime CreatedAt);
+    long GlBankAccountId, string BankAccountName, string? Reference, string? GlJournalNo, DateTime CreatedAt,
+    SalesPaymentMethod PaymentMethod);
 
 public sealed class CreateSalesInvoicePaymentRequest
 {
     [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
     [Required] public long GlBankAccountId { get; set; }
+    /// <summary>How the customer paid. Omitted ⇒ derived from the account: a Cash account ⇒ Cash, a Bank account ⇒ Card.</summary>
+    public SalesPaymentMethod? PaymentMethod { get; set; }
     [StringLength(100)] public string? Reference { get; set; }
     /// <summary>When the customer paid; also the GL entry date. Omitted ⇒ today. Never in the future.</summary>
     public DateOnly? PaymentDate { get; set; }
@@ -43,6 +50,8 @@ public sealed class BulkSalesInvoicePaymentLine
 {
     [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
     [Required] public long GlBankAccountId { get; set; }
+    /// <summary>See <see cref="CreateSalesInvoicePaymentRequest.PaymentMethod"/>.</summary>
+    public SalesPaymentMethod? PaymentMethod { get; set; }
 }
 
 /// <summary>
@@ -95,6 +104,13 @@ public sealed class CreateSalesInvoiceLineRequest
     [Range(0, 100)] public decimal? TaxPct { get; set; }
     public bool IsFreeIssue { get; set; }
     public int? ParentLineId { get; set; }
+    /// <summary>Pins the line to one batch (must belong to the item, not expired). Omit to let posting pick FEFO.</summary>
+    public int? BatchId { get; set; }
+    /// <summary>
+    /// Serials sold on this line — required for a serial-tracked item, one per unit of
+    /// Qty + FreeQty, each InStock at the line warehouse. Rejected for any other item.
+    /// </summary>
+    public List<int>? SerialIds { get; set; }
 }
 
 public sealed class CreateSalesInvoiceRequest
diff --git a/Backend/ERPCore/Dtos/Sales/SalesReturnDtos.cs b/Backend/ERPCore/Dtos/Sales/SalesReturnDtos.cs
index b619d4f..3908393 100644
--- a/Backend/ERPCore/Dtos/Sales/SalesReturnDtos.cs
+++ b/Backend/ERPCore/Dtos/Sales/SalesReturnDtos.cs
@@ -5,7 +5,17 @@ namespace ERPCore.Dtos.Sales;
 
 // Responses -----------------------------------------------------------------
 
-public sealed record SalesReturnLineDto(int ReturnLineId, int? SalesInvoiceLineId, int ItemId, decimal Qty);
+public sealed record SalesReturnLineDto(
+    int ReturnLineId, int? SalesInvoiceLineId, int ItemId, decimal Qty,
+    int? BatchId, IReadOnlyList<SalesLineSerialDto> Serials);
+
+/// <summary>
+/// What one posted sales invoice line issued, net of returns — the batches/serials a return
+/// against it can take back.
+/// </summary>
+public sealed record SalesLineAllocationDto(
+    int? BatchId, string? BatchNo, DateOnly? ExpiryDate, int? SerialId, string? SerialNo,
+    decimal Qty, decimal QtyReturned);
 
 public sealed record SalesReturnDto(
     int ReturnId, string DocNo, int CustomerId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
@@ -22,7 +32,8 @@ public sealed record SalesReturnSummaryDto(
 /// whatever has already been returned against it. The invoice line's own <c>Qty</c>
 /// is never mutated by a return, so this is computed on read from return history.
 /// </summary>
-public sealed record SalesInvoiceLineRemainingDto(int SalesInvoiceLineId, decimal RemainingQty);
+public sealed record SalesInvoiceLineRemainingDto(
+    int SalesInvoiceLineId, decimal RemainingQty, IReadOnlyList<SalesLineAllocationDto> Allocations);
 
 // Requests --------------------------------------------------------------------
 
@@ -32,6 +43,16 @@ public sealed class CreateSalesReturnLineInput
     public int? SalesInvoiceLineId { get; set; }
     [Required] public int ItemId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    /// <summary>
+    /// Batch to restock into. Optional when the invoice line issued a single batch (it is used);
+    /// required for a batch-tracked item otherwise, and must be one the line issued.
+    /// </summary>
+    public int? BatchId { get; set; }
+    /// <summary>
+    /// Returned serials of a serial-tracked item — one per unit, each Sold (and, with an invoice
+    /// line, sold on that line). Rejected for any other item.
+    /// </summary>
+    public List<int>? SerialIds { get; set; }
 }
 
 public sealed class CreateSalesReturnRequest
@@ -40,5 +61,10 @@ public sealed class CreateSalesReturnRequest
     [Required] public int WarehouseId { get; set; }
     /// <summary>Nullable so an omitted value is a distinct <c>REASON_CODE_REQUIRED</c> error.</summary>
     public int? ReasonCodeId { get; set; }
+    /// <summary>
+    /// Returned serials become <c>Damaged</c> (not resaleable) instead of <c>InStock</c>. Omit to
+    /// derive it from the reason: <c>DEF</c> (Defective) and <c>QREJ</c> (Quality Reject) mean damaged.
+    /// </summary>
+    public bool? MarkDamaged { get; set; }
     [Required, MinLength(1)] public List<CreateSalesReturnLineInput> Lines { get; set; } = new();
 }
diff --git a/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs b/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs
index a65bd4e..37af479 100644
--- a/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs
+++ b/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs
@@ -8,11 +8,11 @@ public sealed record SalesSlipLineDto(
     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,
-    int? BatchId, int? SerialId);
+    int? BatchId, int? SerialId, IReadOnlyList<SalesLineSerialDto> Serials);
 
 public sealed record SalesSlipTotalsDto(
     decimal Subtotal, decimal DiscountTotal, decimal FreeQtyTotal, decimal TaxTotal, decimal GrandTotal,
-    decimal PaidAmount, decimal BalanceAmount);
+    decimal PaidAmount, decimal BalanceAmount, decimal CashAmount, decimal CardAmount);
 
 public sealed record SalesSlipDto(
     int SalesSlipId, string SlipNo, DateTime SlipDate, int CustomerId,
@@ -62,8 +62,13 @@ public sealed class CreateSalesSlipLineRequest
     public int? ParentLineId { get; set; }
     /// <summary>Pins the line to a specific batch (must belong to <see cref="ItemId"/>), consumed via FIFO.</summary>
     public int? BatchId { get; set; }
-    /// <summary>Pins the line to a specific serial (must belong to <see cref="ItemId"/>); marked Sold on posting.</summary>
+    /// <summary>Legacy single-serial pin — treated as <c>SerialIds = [SerialId]</c> when <see cref="SerialIds"/> is empty.</summary>
     public int? SerialId { get; set; }
+    /// <summary>
+    /// Serials sold on this line — required for a serial-tracked item, one per unit of
+    /// Qty + FreeQty, each InStock at the line warehouse. Marked Sold on posting.
+    /// </summary>
+    public List<int>? SerialIds { get; set; }
 }
 
 public sealed class CreateSalesSlipRequest
@@ -82,6 +87,10 @@ public sealed class CreateSalesSlipRequest
     /// Receivable when it posts (see SalesDayEndService.CloseAsync).
     /// </summary>
     [Range(0, double.MaxValue)] public decimal? PaidAmount { get; set; }
+
+    /// <summary>The part of the paid amount tendered by card; the rest of it is cash. Omit for all
+    /// cash. Must be between 0 and the paid amount.</summary>
+    [Range(0, double.MaxValue)] public decimal? CardAmount { get; set; }
 }
 
 public sealed class UpdateSalesSlipRequest
@@ -93,4 +102,7 @@ public sealed class UpdateSalesSlipRequest
 
     /// <summary>See <see cref="CreateSalesSlipRequest.PaidAmount"/>.</summary>
     [Range(0, double.MaxValue)] public decimal? PaidAmount { get; set; }
+
+    /// <summary>See <see cref="CreateSalesSlipRequest.CardAmount"/>.</summary>
+    [Range(0, double.MaxValue)] public decimal? CardAmount { get; set; }
 }
diff --git a/Backend/ERPCore/Dtos/Stock/AdjustmentDtos.cs b/Backend/ERPCore/Dtos/Stock/AdjustmentDtos.cs
index 0163c66..ab73e59 100644
--- a/Backend/ERPCore/Dtos/Stock/AdjustmentDtos.cs
+++ b/Backend/ERPCore/Dtos/Stock/AdjustmentDtos.cs
@@ -5,17 +5,29 @@ namespace ERPCore.Dtos.Stock;
 
 // Responses (docs/11 §5.5) ------------------------------------------------------
 
-public sealed record AdjustmentLineDto(int AdjLineId, int ItemId, int? BinId, int? BatchId, decimal QtyDelta);
+/// <param name="RequestedSerialIds">Serials named to write off (shown while the request is pending).</param>
+/// <param name="RequestedSerialNos">Serial numbers named as found (shown while the request is pending).</param>
+public sealed record AdjustmentLineDto(
+    int AdjLineId, int ItemId, int? BinId, int? BatchId, decimal QtyDelta, int? SerialId,
+    IReadOnlyList<int>? RequestedSerialIds = null, IReadOnlyList<string>? RequestedSerialNos = null);
 
+/// <param name="PendingLevel">The approval it waits for (1 or 2); null once decided or posted.</param>
+/// <param name="CanApprove">Whether the current user may give that approval; <paramref name="WhyNot"/> says why not.</param>
 public sealed record AdjustmentDto(
     int AdjustmentId, string DocNo, int WarehouseId, int BranchId, int ReasonCodeId, AdjustmentStatus Status,
     int CreatedBy, DateTime CreatedAt, string? GlJournalNo, DateTime? GlPostedAt,
-    IReadOnlyList<AdjustmentLineDto> Lines, IReadOnlyList<int> LedgerRefs);
+    IReadOnlyList<AdjustmentLineDto> Lines, IReadOnlyList<int> LedgerRefs,
+    int RequiredApprovals = 0, int? PendingLevel = null,
+    int? ApprovedLevel1By = null, DateTime? ApprovedLevel1At = null, int? ApprovedLevel2By = null, DateTime? ApprovedLevel2At = null,
+    int? RejectedBy = null, DateTime? RejectedAt = null, string? RejectReason = null, DateTime? PostedAt = null,
+    IReadOnlyList<Approvals.ApprovalStepDto>? ApprovalHistory = null, bool CanApprove = false, string? WhyNot = null,
+    bool CanWithdraw = false, string? CreatedByName = null);
 
 /// <summary>Row shape for <c>GET /stock-adjustments</c> — no lines/ledgerRefs (those need a per-row query).</summary>
 public sealed record AdjustmentSummaryDto(
     int AdjustmentId, string DocNo, int WarehouseId, int BranchId, int ReasonCodeId, AdjustmentStatus Status,
-    int CreatedBy, DateTime CreatedAt, int LineCount, string? GlJournalNo);
+    int CreatedBy, DateTime CreatedAt, int LineCount, string? GlJournalNo,
+    int RequiredApprovals = 0, int? PendingLevel = null);
 
 // Requests ----------------------------------------------------------------------
 
@@ -26,6 +38,16 @@ public sealed class CreateAdjustmentLineInput
     public int? BatchId { get; set; }
     /// <summary>Signed base-UOM delta: negative consumes FIFO layers, positive adds stock.</summary>
     public decimal QtyDelta { get; set; }
+    /// <summary>
+    /// Negative delta on a serial-tracked item: the serials written off (InStock or Damaged at
+    /// the warehouse, one per unit) — they become <c>Scrapped</c>.
+    /// </summary>
+    public List<int>? SerialIds { get; set; }
+    /// <summary>
+    /// Positive delta on a serial-tracked item: the serial numbers found (one per unit) — new
+    /// numbers are created, a known serial that is out of stock is brought back InStock.
+    /// </summary>
+    public List<string>? SerialNos { get; set; }
 }
 
 public sealed class CreateAdjustmentRequest
diff --git a/Backend/ERPCore/Dtos/Stock/CountDtos.cs b/Backend/ERPCore/Dtos/Stock/CountDtos.cs
index ab4a238..95f1618 100644
--- a/Backend/ERPCore/Dtos/Stock/CountDtos.cs
+++ b/Backend/ERPCore/Dtos/Stock/CountDtos.cs
@@ -18,7 +18,10 @@ public sealed record CountSummaryDto(
     int CountId, string DocNo, int WarehouseId, int BranchId, CountType CountType, CountStatus Status,
     int CreatedBy, DateTime CreatedAt, int LineCount);
 
-public sealed record CountPostResultDto(int CountId, CountStatus Status, int? AdjustmentId, string? GlJournalNo, IReadOnlyList<int> LedgerRefs);
+/// <param name="AdjustmentStatus">The variance adjustment's status — <c>PendingApproval</c> when it must be approved before stock moves.</param>
+public sealed record CountPostResultDto(
+    int CountId, CountStatus Status, int? AdjustmentId, string? GlJournalNo, IReadOnlyList<int> LedgerRefs,
+    AdjustmentStatus? AdjustmentStatus = null, string? AdjustmentDocNo = null);
 
 // Requests ----------------------------------------------------------------------
 
diff --git a/Backend/ERPCore/Dtos/Stock/TrackingDtos.cs b/Backend/ERPCore/Dtos/Stock/TrackingDtos.cs
new file mode 100644
index 0000000..c39ee57
--- /dev/null
+++ b/Backend/ERPCore/Dtos/Stock/TrackingDtos.cs
@@ -0,0 +1,40 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Stock;
+
+// Item tracking lookups and registers (docs/ITEM_TRACKING_PLAN.md Phases 5, 8, 9).
+
+/// <summary>Product Configuration tracking switches, as every screen needs them.</summary>
+public sealed record TrackingSettingsDto(bool SerialNumbersEnabled);
+
+/// <summary>An issuable serial, for sale/transfer/return pickers.</summary>
+public sealed record AvailableSerialDto(int SerialId, string SerialNo, int? BatchId, string? BatchNo, SerialStatus Status);
+
+/// <summary>Issuable stock of one batch at a warehouse (BatchId null = unbatched stock).</summary>
+public sealed record AvailableBatchDto(int? BatchId, string? BatchNo, DateOnly? ExpiryDate, decimal Qty, int? DaysToExpiry);
+
+/// <summary>A FEFO pick: <see cref="Qty"/> of <see cref="BatchId"/>.</summary>
+public sealed record BatchSuggestionDto(int? BatchId, string? BatchNo, DateOnly? ExpiryDate, decimal Qty);
+
+public sealed record SerialSummaryDto(
+    int SerialId, int ItemId, string Sku, string ItemName, string SerialNo, SerialStatus Status,
+    int? WarehouseId, string? WarehouseName, int? BinId, DateTime? ReceivedAt,
+    int? GrnId, string? GrnDocNo, int? WarrantyPeriodMonths);
+
+public sealed record SerialMovementDto(
+    int SerialMovementId, string SourceDocType, int SourceDocId, SerialStatus Status,
+    int? FromWarehouseId, int? WarehouseId, int UserId, DateTime CreatedAt);
+
+public sealed record SerialDetailDto(
+    SerialSummaryDto Serial, IReadOnlyList<SerialMovementDto> History, IReadOnlyList<WarrantyRegistrationDto> Warranties);
+
+public sealed record WarrantyRegistrationDto(
+    int WarrantyRegistrationId, int ItemId, string Sku, string ItemName, int? SerialId, string? SerialNo,
+    int CustomerId, string CustomerName, string SourceDocType, int SourceDocId, int SourceLineId,
+    decimal Qty, DateOnly StartDate, int PeriodMonths, DateOnly EndDate, WarrantyStatus Status,
+    int DaysRemaining, bool IsExpired);
+
+/// <summary>Stock on hand per batch (with expiry), for the batch / expiry report.</summary>
+public sealed record BatchStockDto(
+    int ItemId, string Sku, string ItemName, int WarehouseId, string WarehouseName,
+    int? BatchId, string? BatchNo, DateOnly? ExpiryDate, decimal Qty, int? DaysToExpiry, bool IsExpired);
diff --git a/Backend/ERPCore/Dtos/Stock/TransferDtos.cs b/Backend/ERPCore/Dtos/Stock/TransferDtos.cs
index 08cf57f..ad6c02e 100644
--- a/Backend/ERPCore/Dtos/Stock/TransferDtos.cs
+++ b/Backend/ERPCore/Dtos/Stock/TransferDtos.cs
@@ -6,7 +6,11 @@ namespace ERPCore.Dtos.Stock;
 // Responses (docs/11 §5.4) ------------------------------------------------------
 
 public sealed record TransferLineDto(
-    int TransferLineId, int ItemId, int? SrcBinId, int? DestBinId, int? BatchId, decimal Qty, decimal QtyReceived);
+    int TransferLineId, int ItemId, int? SrcBinId, int? DestBinId, int? BatchId, decimal Qty, decimal QtyReceived,
+    IReadOnlyList<TransferLineSerialDto> Serials);
+
+/// <summary>A serial on a transfer line; <see cref="Received"/> once it has arrived.</summary>
+public sealed record TransferLineSerialDto(int SerialId, string SerialNo, bool Received);
 
 public sealed record TransferDto(
     int TransferId, string DocNo, int SrcWarehouseId, int DestWarehouseId, int BranchId,
@@ -34,8 +38,11 @@ public sealed class CreateTransferLineInput
     [Required] public int ItemId { get; set; }
     public int? SrcBinId { get; set; }
     public int? DestBinId { get; set; }
+    /// <summary>Batch to move. Omitted for a batch-tracked item, the line is split FEFO across batches.</summary>
     public int? BatchId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    /// <summary>Serials to move — required for a serial-tracked item, one per unit, each InStock at the source.</summary>
+    public List<int>? SerialIds { get; set; }
 }
 
 public sealed class CreateTransferRequest
@@ -52,6 +59,11 @@ public sealed class ReceiveTransferLineInput
 {
     [Required] public int TransferLineId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    /// <summary>
+    /// For a serial line: which in-transit serials arrived (count = Qty). May be omitted when
+    /// receiving everything still outstanding on the line.
+    /// </summary>
+    public List<int>? SerialIds { get; set; }
 }
 
 public sealed class ReceiveTransferRequest
diff --git a/Backend/ERPCore/Infra/Filters/LowStockAlertFilter.cs b/Backend/ERPCore/Infra/Filters/LowStockAlertFilter.cs
new file mode 100644
index 0000000..325341a
--- /dev/null
+++ b/Backend/ERPCore/Infra/Filters/LowStockAlertFilter.cs
@@ -0,0 +1,34 @@
+using ERPCore.Services.Stock;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace ERPCore.Infra.Filters;
+
+/// <summary>
+/// After every API action that succeeded, checks whether its stock issues pushed anything to or
+/// below its reorder point (<see cref="LowStockAlertService"/>). By then the action's UoW
+/// transaction has committed, so only stock that really left is alerted on. The check is
+/// best-effort: a failure is logged and never fails the request that moved the stock.
+/// </summary>
+public sealed class LowStockAlertFilter(LowStockAlertService alerts, LowStockTracker tracker, ILogger<LowStockAlertFilter> logger) : IAsyncActionFilter
+{
+    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        var executed = await next();
+
+        // A failed action rolled its transaction back: nothing it "issued" actually left stock.
+        if (executed.Exception is not null && !executed.ExceptionHandled)
+        {
+            tracker.Drain();
+            return;
+        }
+
+        try
+        {
+            await alerts.CheckAsync(context.HttpContext.RequestAborted);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            logger.LogWarning(ex, "Low-stock check failed after {Path}", context.HttpContext.Request.Path);
+        }
+    }
+}
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/ApprovalConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/ApprovalConfiguration.cs
new file mode 100644
index 0000000..a301c8d
--- /dev/null
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/ApprovalConfiguration.cs
@@ -0,0 +1,99 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+/// <summary>Dual approval tables (docs/DUAL_APPROVAL_PLAN.md §4, §6, §7).</summary>
+public sealed class DocumentApprovalConfiguration : IEntityTypeConfiguration<DocumentApproval>
+{
+    public void Configure(EntityTypeBuilder<DocumentApproval> builder)
+    {
+        builder.ToTable("document_approvals");
+        builder.HasKey(a => a.DocumentApprovalId);
+
+        builder.Property(a => a.DocType).IsRequired().HasMaxLength(10);
+        builder.Property(a => a.Decision).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(a => a.Comment).HasMaxLength(250);
+        builder.Property(a => a.DecidedAt).IsRequired();
+
+        builder.HasOne(a => a.Decider).WithMany().HasForeignKey(a => a.DecidedBy).OnDelete(DeleteBehavior.Restrict);
+        builder.HasIndex(a => new { a.DocType, a.DocId });
+    }
+}
+
+public sealed class ApprovalConfigConfiguration : IEntityTypeConfiguration<ApprovalConfig>
+{
+    public void Configure(EntityTypeBuilder<ApprovalConfig> builder)
+    {
+        builder.ToTable("approval_config", t =>
+            t.HasCheckConstraint("ck_approval_config_singleton", $"`ApprovalConfigId` = {ApprovalConfig.SingletonId}"));
+        builder.HasKey(c => c.ApprovalConfigId);
+        builder.Property(c => c.ApprovalConfigId).ValueGeneratedNever();
+
+        builder.Property(c => c.StockAdjustmentLevel2ThresholdValue).HasPrecision(18, 4);
+        builder.Property(c => c.PriceAdjustmentLevel2ThresholdPercent).HasPrecision(9, 4);
+        builder.Property(c => c.Level2RoleCodes).HasMaxLength(500);
+
+        // Dual approval on by default for both documents (plan §8 recommended defaults).
+        builder.HasData(new ApprovalConfig
+        {
+            ApprovalConfigId = ApprovalConfig.SingletonId,
+            StockAdjustmentLevels = 2,
+            PriceAdjustmentLevels = 2,
+            RowVersion = 1
+        });
+    }
+}
+
+public sealed class PriceAdjustmentConfiguration : IEntityTypeConfiguration<PriceAdjustment>
+{
+    public void Configure(EntityTypeBuilder<PriceAdjustment> builder)
+    {
+        builder.ToTable("price_adjustments");
+        builder.HasKey(p => p.PriceAdjustmentId);
+
+        builder.Property(p => p.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(p => p.DocNo).IsUnique();
+        builder.Property(p => p.Reason).IsRequired().HasMaxLength(250);
+        builder.Property(p => p.Status).HasConversion<string>().HasMaxLength(30).IsRequired()
+            .HasDefaultValue(PriceAdjustmentStatus.PendingApproval);
+        builder.Property(p => p.RejectReason).HasMaxLength(250);
+        builder.Property(p => p.CreatedAt).IsRequired();
+
+        builder.HasOne(p => p.Creator).WithMany().HasForeignKey(p => p.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+        builder.HasMany(p => p.Lines).WithOne(l => l.PriceAdjustment).HasForeignKey(l => l.PriceAdjustmentId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasIndex(p => p.Status);
+    }
+}
+
+public sealed class PriceAdjustmentLineConfiguration : IEntityTypeConfiguration<PriceAdjustmentLine>
+{
+    public void Configure(EntityTypeBuilder<PriceAdjustmentLine> builder)
+    {
+        builder.ToTable("price_adjustment_lines");
+        builder.HasKey(l => l.PriceAdjustmentLineId);
+        foreach (var p in new[] { nameof(PriceAdjustmentLine.OldMinPrice), nameof(PriceAdjustmentLine.OldMaxPrice), nameof(PriceAdjustmentLine.OldFlatPrice),
+                     nameof(PriceAdjustmentLine.NewMinPrice), nameof(PriceAdjustmentLine.NewMaxPrice), nameof(PriceAdjustmentLine.NewFlatPrice) })
+            builder.Property<decimal?>(p).HasPrecision(18, 4);
+        builder.HasOne(l => l.Item).WithMany().HasForeignKey(l => l.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasIndex(l => l.ItemId);
+    }
+}
+
+public sealed class ItemPriceHistoryConfiguration : IEntityTypeConfiguration<ItemPriceHistory>
+{
+    public void Configure(EntityTypeBuilder<ItemPriceHistory> builder)
+    {
+        builder.ToTable("item_price_history");
+        builder.HasKey(h => h.ItemPriceHistoryId);
+        foreach (var p in new[] { nameof(ItemPriceHistory.OldMinPrice), nameof(ItemPriceHistory.OldMaxPrice), nameof(ItemPriceHistory.OldFlatPrice),
+                     nameof(ItemPriceHistory.NewMinPrice), nameof(ItemPriceHistory.NewMaxPrice), nameof(ItemPriceHistory.NewFlatPrice) })
+            builder.Property<decimal?>(p).HasPrecision(18, 4);
+        builder.Property(h => h.AppliedAt).IsRequired();
+        builder.HasOne(h => h.Item).WithMany().HasForeignKey(h => h.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(h => h.PriceAdjustment).WithMany().HasForeignKey(h => h.PriceAdjustmentId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasIndex(h => new { h.ItemId, h.AppliedAt });
+    }
+}
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/BankDepositConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/BankDepositConfiguration.cs
new file mode 100644
index 0000000..139622d
--- /dev/null
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/BankDepositConfiguration.cs
@@ -0,0 +1,50 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+/// <summary>Bank deposits of till cash (docs/BANK_DEPOSIT_MODULE_PLAN.md §4).</summary>
+public sealed class BankDepositConfiguration : IEntityTypeConfiguration<BankDeposit>
+{
+    public void Configure(EntityTypeBuilder<BankDeposit> builder)
+    {
+        builder.ToTable("bank_deposits", t =>
+            t.HasCheckConstraint("ck_bank_deposits_amount", "`Amount` > 0"));
+        builder.HasKey(x => x.BankDepositId);
+
+        builder.Property(x => x.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(x => x.DocNo).IsUnique();
+
+        builder.Property(x => x.BusinessDate).IsRequired();
+        builder.Property(x => x.DepositDate).IsRequired();
+        builder.Property(x => x.Amount).HasPrecision(18, 4);
+
+        builder.Property(x => x.FromCashAccountCode).IsRequired().HasMaxLength(20);
+        builder.Property(x => x.FromCashAccountName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.ToBankAccountCode).IsRequired().HasMaxLength(20);
+        builder.Property(x => x.ToBankAccountName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.ToBankName).HasMaxLength(150);
+        builder.Property(x => x.ToAccountNumber).HasMaxLength(50);
+
+        builder.Property(x => x.DepositSlipNo).HasMaxLength(50);
+        builder.Property(x => x.DepositedBy).HasMaxLength(150);
+        builder.Property(x => x.Remarks).HasMaxLength(500);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(BankDepositStatus.Posted);
+
+        builder.Property(x => x.GlJournalNo).HasMaxLength(30);
+        builder.Property(x => x.GlReversalJournalNo).HasMaxLength(30);
+        builder.Property(x => x.CancelReason).HasMaxLength(250);
+        builder.Property(x => x.CreatedAt).IsRequired();
+
+        builder.HasOne(x => x.Branch).WithMany().HasForeignKey(x => x.BranchId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Creator).WithMany().HasForeignKey(x => x.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => new { x.BranchId, x.BusinessDate, x.Status });
+        builder.HasIndex(x => x.ToGlBankAccountId);
+    }
+}
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/BatchSerialConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/BatchSerialConfiguration.cs
index db9ea87..6ea7b5b 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/BatchSerialConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/BatchSerialConfiguration.cs
@@ -34,7 +34,9 @@ public sealed class SerialConfiguration : IEntityTypeConfiguration<Serial>
         builder.HasKey(s => s.SerialId);
 
         builder.Property(s => s.SerialNo).IsRequired().HasMaxLength(100);
-        builder.Property(s => s.Status).IsRequired().HasMaxLength(20);
+        // String-stored enum: rows written as "InStock"/"Sold" before SerialStatus existed
+        // read back unchanged.
+        builder.Property(s => s.Status).HasConversion<string>().IsRequired().HasMaxLength(20);
 
         builder.Property(s => s.Barcode).HasMaxLength(100);
         builder.HasIndex(s => s.Barcode).IsUnique();
@@ -43,7 +45,12 @@ public sealed class SerialConfiguration : IEntityTypeConfiguration<Serial>
             .WithMany()
             .HasForeignKey(s => s.ItemId)
             .OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(s => s.Warehouse).WithMany().HasForeignKey(s => s.WarehouseId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(s => s.Bin).WithMany().HasForeignKey(s => s.BinId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(s => s.GrnLine).WithMany().HasForeignKey(s => s.GrnLineId).OnDelete(DeleteBehavior.Restrict);
 
         builder.HasIndex(s => new { s.ItemId, s.SerialNo }).IsUnique();
+        builder.HasIndex(s => new { s.ItemId, s.Status });
+        builder.HasIndex(s => new { s.WarehouseId, s.ItemId, s.Status });
     }
 }
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleConfiguration.cs
index 3d4b9bd..6a26160 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleConfiguration.cs
@@ -26,6 +26,8 @@ public sealed class BundleSaleConfiguration : IEntityTypeConfiguration<BundleSal
         builder.Property(x => x.DiscountTotal).HasPrecision(18, 4);
         builder.Property(x => x.TaxTotal).HasPrecision(18, 4);
         builder.Property(x => x.GrandTotal).HasPrecision(18, 4);
+        builder.Property(x => x.CashAmount).HasPrecision(18, 4);
+        builder.Property(x => x.CardAmount).HasPrecision(18, 4);
         builder.Property(x => x.CreatedAt).IsRequired();
 
         builder.HasOne(x => x.Customer).WithMany().HasForeignKey(x => x.CustomerId).OnDelete(DeleteBehavior.Restrict);
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/ExpenseConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/ExpenseConfiguration.cs
new file mode 100644
index 0000000..1360f78
--- /dev/null
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/ExpenseConfiguration.cs
@@ -0,0 +1,170 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+/// <summary>
+/// Expense module tables (docs/EXPENSE_MODULE_PLAN.md §3). The four categories and their
+/// titles are seeded as <c>IsSystem</c> rows. The GL codes are the children of the GL
+/// "Operating Expenses" (5200) control account created for this module on 2026-10-08 — GL
+/// generates codes itself, so a GL instance with a different chart needs these corrected per
+/// title on the Expense Setup screen.
+/// </summary>
+public sealed class ExpenseCategoryConfiguration : IEntityTypeConfiguration<ExpenseCategory>
+{
+    public const string UtilityGlCode = "5200-01";
+    public const string RentalGlCode = "5200-02";
+    public const string SalariesGlCode = "5200-03";
+    public const string OtherGlCode = "5200-04";
+
+    public void Configure(EntityTypeBuilder<ExpenseCategory> builder)
+    {
+        builder.ToTable("expense_categories");
+        builder.HasKey(c => c.ExpenseCategoryId);
+
+        builder.Property(c => c.Code).IsRequired().HasMaxLength(30);
+        builder.HasIndex(c => c.Code).IsUnique();
+        builder.Property(c => c.Name).IsRequired().HasMaxLength(100);
+        builder.HasIndex(c => c.Name).IsUnique();
+
+        builder.Property(c => c.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(EntityStatus.Active);
+        builder.Property(c => c.CreatedAt).IsRequired();
+
+        builder.HasMany(c => c.Titles)
+            .WithOne(t => t.Category)
+            .HasForeignKey(t => t.ExpenseCategoryId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        var seededAt = new DateTime(2026, 10, 7, 0, 0, 0, DateTimeKind.Utc);
+        builder.HasData(
+            new ExpenseCategory { ExpenseCategoryId = 1, Code = "UTILITY", Name = "Utility", IsSystem = true, SortOrder = 1, CreatedAt = seededAt, RowVersion = 1 },
+            new ExpenseCategory { ExpenseCategoryId = 2, Code = "RENTAL", Name = "Rental", IsSystem = true, SortOrder = 2, CreatedAt = seededAt, RowVersion = 1 },
+            new ExpenseCategory { ExpenseCategoryId = 3, Code = "SALARIES", Name = "Salaries", IsSystem = true, SortOrder = 3, CreatedAt = seededAt, RowVersion = 1 },
+            new ExpenseCategory { ExpenseCategoryId = 4, Code = "OTHER", Name = "Other", IsSystem = true, SortOrder = 4, CreatedAt = seededAt, RowVersion = 1 }
+        );
+    }
+}
+
+public sealed class ExpenseTitleConfiguration : IEntityTypeConfiguration<ExpenseTitle>
+{
+    public void Configure(EntityTypeBuilder<ExpenseTitle> builder)
+    {
+        builder.ToTable("expense_titles");
+        builder.HasKey(t => t.ExpenseTitleId);
+
+        builder.Property(t => t.Name).IsRequired().HasMaxLength(100);
+        builder.HasIndex(t => new { t.ExpenseCategoryId, t.Name }).IsUnique();
+        builder.Property(t => t.GlExpenseAccountCode).IsRequired().HasMaxLength(20);
+
+        builder.Property(t => t.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(EntityStatus.Active);
+        builder.Property(t => t.CreatedAt).IsRequired();
+
+        var seededAt = new DateTime(2026, 10, 7, 0, 0, 0, DateTimeKind.Utc);
+        var id = 0;
+        ExpenseTitle Seed(int categoryId, string name, string glCode, int sortOrder) => new()
+        {
+            ExpenseTitleId = ++id, ExpenseCategoryId = categoryId, Name = name, GlExpenseAccountCode = glCode,
+            IsSystem = true, SortOrder = sortOrder, CreatedAt = seededAt, RowVersion = 1
+        };
+
+        // Append only — the ids are assigned in this order, so reordering would renumber seeded rows.
+        builder.HasData(
+            Seed(1, "Electricity", ExpenseCategoryConfiguration.UtilityGlCode, 1),
+            Seed(1, "Water", ExpenseCategoryConfiguration.UtilityGlCode, 2),
+            Seed(1, "Telephone", ExpenseCategoryConfiguration.UtilityGlCode, 3),
+            Seed(1, "Internet", ExpenseCategoryConfiguration.UtilityGlCode, 4),
+            Seed(1, "Gas", ExpenseCategoryConfiguration.UtilityGlCode, 5),
+            Seed(2, "Building Rent", ExpenseCategoryConfiguration.RentalGlCode, 1),
+            Seed(2, "Vehicle Rent", ExpenseCategoryConfiguration.RentalGlCode, 2),
+            Seed(2, "Equipment Rent", ExpenseCategoryConfiguration.RentalGlCode, 3),
+            Seed(3, "Staff Salaries", ExpenseCategoryConfiguration.SalariesGlCode, 1),
+            Seed(3, "Wages", ExpenseCategoryConfiguration.SalariesGlCode, 2),
+            Seed(3, "Overtime", ExpenseCategoryConfiguration.SalariesGlCode, 3),
+            Seed(3, "Bonus", ExpenseCategoryConfiguration.SalariesGlCode, 4),
+            Seed(3, "EPF / ETF Contribution", ExpenseCategoryConfiguration.SalariesGlCode, 5),
+            Seed(4, "Stationery", ExpenseCategoryConfiguration.OtherGlCode, 1),
+            Seed(4, "Transport", ExpenseCategoryConfiguration.OtherGlCode, 2),
+            Seed(4, "Repairs & Maintenance", ExpenseCategoryConfiguration.OtherGlCode, 3),
+            Seed(4, "Cleaning", ExpenseCategoryConfiguration.OtherGlCode, 4),
+            Seed(4, "Miscellaneous", ExpenseCategoryConfiguration.OtherGlCode, 5)
+        );
+    }
+}
+
+public sealed class ExpenseConfiguration : IEntityTypeConfiguration<Expense>
+{
+    public void Configure(EntityTypeBuilder<Expense> builder)
+    {
+        builder.ToTable("expenses", t =>
+            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0"));
+        builder.HasKey(x => x.ExpenseId);
+
+        builder.Property(x => x.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(x => x.DocNo).IsUnique();
+
+        builder.Property(x => x.ExpenseDate).IsRequired();
+        builder.Property(x => x.Payee).HasMaxLength(150);
+        builder.Property(x => x.BillReference).HasMaxLength(50);
+        builder.Property(x => x.Description).HasMaxLength(500);
+        builder.Property(x => x.PeriodMonth).HasMaxLength(7);
+
+        foreach (var p in new[] { nameof(Expense.Amount), nameof(Expense.PaidAmount), nameof(Expense.BalanceAmount) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(ExpenseStatus.Draft);
+        builder.Property(x => x.PaymentStatus)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(ExpensePaymentStatus.Unpaid);
+
+        builder.Property(x => x.GlExpenseAccountCode).HasMaxLength(20);
+        builder.Property(x => x.GlJournalNo).HasMaxLength(30);
+        builder.Property(x => x.GlReversalJournalNo).HasMaxLength(30);
+        builder.Property(x => x.CancelReason).HasMaxLength(250);
+        builder.Property(x => x.CreatedAt).IsRequired();
+
+        builder.HasOne(x => x.Category).WithMany().HasForeignKey(x => x.ExpenseCategoryId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Title).WithMany().HasForeignKey(x => x.ExpenseTitleId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Vendor).WithMany().HasForeignKey(x => x.VendorId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Branch).WithMany().HasForeignKey(x => x.BranchId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Creator).WithMany().HasForeignKey(x => x.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasMany(x => x.Payments)
+            .WithOne(p => p.Expense)
+            .HasForeignKey(p => p.ExpenseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => x.Status);
+        builder.HasIndex(x => x.PaymentStatus);
+        builder.HasIndex(x => x.ExpenseDate);
+        builder.HasIndex(x => x.BranchId);
+    }
+}
+
+public sealed class ExpensePaymentConfiguration : IEntityTypeConfiguration<ExpensePayment>
+{
+    public void Configure(EntityTypeBuilder<ExpensePayment> builder)
+    {
+        builder.ToTable("expense_payments");
+        builder.HasKey(p => p.ExpensePaymentId);
+
+        builder.Property(p => p.Amount).HasPrecision(18, 4);
+        builder.Property(p => p.PaymentDate).IsRequired();
+        builder.Property(p => p.PaymentMethod).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(p => p.BankAccountName).IsRequired().HasMaxLength(200);
+        builder.Property(p => p.ChequeNo).HasMaxLength(30);
+        builder.Property(p => p.Reference).HasMaxLength(100);
+        builder.Property(p => p.GlJournalNo).HasMaxLength(30);
+        builder.Property(p => p.CreatedAt).IsRequired();
+
+        builder.HasOne(p => p.Creator).WithMany().HasForeignKey(p => p.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+        builder.HasIndex(p => p.ExpenseId);
+    }
+}
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/GrnConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/GrnConfiguration.cs
index ea1c232..fc71fe8 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/GrnConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/GrnConfiguration.cs
@@ -74,3 +74,23 @@ public sealed class GrnLineWarrantyNumberConfiguration : IEntityTypeConfiguratio
         builder.HasIndex(w => new { w.GrnLineId, w.WarrantyNo }).IsUnique();
     }
 }
+
+public sealed class GrnLineSerialConfiguration : IEntityTypeConfiguration<GrnLineSerial>
+{
+    public void Configure(EntityTypeBuilder<GrnLineSerial> builder)
+    {
+        builder.ToTable("grn_line_serials");
+        builder.HasKey(s => s.GrnLineSerialId);
+
+        builder.Property(s => s.SerialNo).IsRequired().HasMaxLength(100);
+
+        builder.HasOne(s => s.GrnLine).WithMany(l => l.Serials)
+            .HasForeignKey(s => s.GrnLineId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasOne(s => s.Serial).WithMany()
+            .HasForeignKey(s => s.SerialId).OnDelete(DeleteBehavior.Restrict);
+
+        // Global uniqueness lives on serials (ItemId, SerialNo); this only stops a number
+        // being entered twice on one line.
+        builder.HasIndex(s => new { s.GrnLineId, s.SerialNo }).IsUnique();
+    }
+}
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/ItemTrackingConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/ItemTrackingConfiguration.cs
new file mode 100644
index 0000000..d60ea1e
--- /dev/null
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/ItemTrackingConfiguration.cs
@@ -0,0 +1,118 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+// Sales-side serial/batch tracking and warranty (docs/ITEM_TRACKING_PLAN.md Phases 4–5).
+
+public sealed class SalesInvoiceLineSerialConfiguration : IEntityTypeConfiguration<SalesInvoiceLineSerial>
+{
+    public void Configure(EntityTypeBuilder<SalesInvoiceLineSerial> builder)
+    {
+        builder.ToTable("sales_invoice_line_serials");
+        builder.HasKey(x => x.SalesInvoiceLineSerialId);
+
+        builder.HasOne(x => x.SalesInvoiceLine).WithMany(l => l.Serials)
+            .HasForeignKey(x => x.SalesInvoiceLineId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasOne(x => x.Serial).WithMany()
+            .HasForeignKey(x => x.SerialId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => new { x.SalesInvoiceLineId, x.SerialId }).IsUnique();
+    }
+}
+
+public sealed class SalesSlipLineSerialConfiguration : IEntityTypeConfiguration<SalesSlipLineSerial>
+{
+    public void Configure(EntityTypeBuilder<SalesSlipLineSerial> builder)
+    {
+        builder.ToTable("sales_slip_line_serials");
+        builder.HasKey(x => x.SalesSlipLineSerialId);
+
+        builder.HasOne(x => x.SalesSlipLine).WithMany(l => l.Serials)
+            .HasForeignKey(x => x.SalesSlipLineId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasOne(x => x.Serial).WithMany()
+            .HasForeignKey(x => x.SerialId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => new { x.SalesSlipLineId, x.SerialId }).IsUnique();
+    }
+}
+
+public sealed class SalesLineAllocationConfiguration : IEntityTypeConfiguration<SalesLineAllocation>
+{
+    public void Configure(EntityTypeBuilder<SalesLineAllocation> builder)
+    {
+        builder.ToTable("sales_line_allocations");
+        builder.HasKey(x => x.SalesLineAllocationId);
+
+        builder.Property(x => x.SourceDocType).IsRequired().HasMaxLength(50);
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.QtyReturned).HasPrecision(18, 4);
+        builder.Property(x => x.UnitCost).HasPrecision(18, 6);
+
+        builder.HasOne(x => x.Batch).WithMany().HasForeignKey(x => x.BatchId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Serial).WithMany().HasForeignKey(x => x.SerialId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => new { x.SourceDocType, x.SourceDocId, x.SourceLineId });
+        builder.HasIndex(x => x.SerialId);
+        builder.HasIndex(x => x.BatchId);
+    }
+}
+
+public sealed class StockTransferLineSerialConfiguration : IEntityTypeConfiguration<StockTransferLineSerial>
+{
+    public void Configure(EntityTypeBuilder<StockTransferLineSerial> builder)
+    {
+        builder.ToTable("stock_transfer_line_serials");
+        builder.HasKey(x => x.StockTransferLineSerialId);
+
+        builder.Property(x => x.UnitCost).HasPrecision(18, 6);
+
+        builder.HasOne(x => x.TransferLine).WithMany(l => l.Serials)
+            .HasForeignKey(x => x.TransferLineId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasOne(x => x.Serial).WithMany()
+            .HasForeignKey(x => x.SerialId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne<Batch>().WithMany().HasForeignKey(x => x.BatchId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => new { x.TransferLineId, x.SerialId }).IsUnique();
+    }
+}
+
+public sealed class SerialMovementConfiguration : IEntityTypeConfiguration<SerialMovement>
+{
+    public void Configure(EntityTypeBuilder<SerialMovement> builder)
+    {
+        builder.ToTable("serial_movements");
+        builder.HasKey(x => x.SerialMovementId);
+
+        builder.Property(x => x.SourceDocType).IsRequired().HasMaxLength(50);
+        builder.Property(x => x.Status).HasConversion<string>().IsRequired().HasMaxLength(20);
+
+        builder.HasOne(x => x.Serial).WithMany().HasForeignKey(x => x.SerialId).OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasIndex(x => new { x.SerialId, x.SerialMovementId });
+        builder.HasIndex(x => new { x.SourceDocType, x.SourceDocId });
+    }
+}
+
+public sealed class WarrantyRegistrationConfiguration : IEntityTypeConfiguration<WarrantyRegistration>
+{
+    public void Configure(EntityTypeBuilder<WarrantyRegistration> builder)
+    {
+        builder.ToTable("warranty_registrations");
+        builder.HasKey(x => x.WarrantyRegistrationId);
+
+        builder.Property(x => x.SourceDocType).IsRequired().HasMaxLength(50);
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.Status).HasConversion<string>().IsRequired().HasMaxLength(20);
+
+        builder.HasOne(x => x.Item).WithMany().HasForeignKey(x => x.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Serial).WithMany().HasForeignKey(x => x.SerialId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Customer).WithMany().HasForeignKey(x => x.CustomerId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(x => x.SerialId);
+        builder.HasIndex(x => x.CustomerId);
+        builder.HasIndex(x => new { x.SourceDocType, x.SourceDocId });
+        builder.HasIndex(x => new { x.Status, x.EndDate });
+    }
+}
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/PermissionConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/PermissionConfiguration.cs
index 843a3b8..b7dacac 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/PermissionConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/PermissionConfiguration.cs
@@ -84,7 +84,13 @@ public sealed class PermissionConfiguration : IEntityTypeConfiguration<Permissio
             new Permission { PermissionId = 50, Code = "NAV:sales.invoices", SubNavItemId = 40 },
             new Permission { PermissionId = 51, Code = "NAV:sales.free-issues", SubNavItemId = 41 },
             new Permission { PermissionId = 52, Code = "NAV:sales.day-end", SubNavItemId = 42 },
-            new Permission { PermissionId = 53, Code = "NAV:products.tax-rates", SubNavItemId = 43 }
+            new Permission { PermissionId = 53, Code = "NAV:products.tax-rates", SubNavItemId = 43 },
+            new Permission { PermissionId = 54, Code = "NAV:accounts.expenses", SubNavItemId = 44 },
+            new Permission { PermissionId = 55, Code = "NAV:accounts.expense-setup", SubNavItemId = 45 },
+            new Permission { PermissionId = 56, Code = "NAV:sales.day-end-report", SubNavItemId = 46 },
+            new Permission { PermissionId = 57, Code = "NAV:accounts.bank-deposits", SubNavItemId = 47 },
+            new Permission { PermissionId = 58, Code = "NAV:products.price-adjustments", SubNavItemId = 48 },
+            new Permission { PermissionId = 59, Code = "NAV:settings.approvals", SubNavItemId = 49 }
         );
     }
 }
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/SalesInvoiceConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/SalesInvoiceConfiguration.cs
index f759bdc..e5bf85a 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/SalesInvoiceConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/SalesInvoiceConfiguration.cs
@@ -70,6 +70,9 @@ public sealed class SalesInvoicePaymentConfiguration : IEntityTypeConfiguration<
         builder.Property(p => p.Amount).HasPrecision(18, 4);
         builder.Property(p => p.PaymentDate).IsRequired();
         builder.Property(p => p.BankAccountName).IsRequired().HasMaxLength(200);
+        builder.Property(p => p.PaymentMethod)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesPaymentMethod.Cash);
         builder.Property(p => p.Reference).HasMaxLength(100);
         builder.Property(p => p.GlJournalNo).HasMaxLength(30);
         builder.Property(p => p.CreatedAt).IsRequired();
@@ -111,6 +114,11 @@ public sealed class SalesInvoiceLineConfiguration : IEntityTypeConfiguration<Sal
             .HasForeignKey(x => x.WarehouseId)
             .OnDelete(DeleteBehavior.Restrict);
 
+        builder.HasOne(x => x.Batch)
+            .WithMany()
+            .HasForeignKey(x => x.BatchId)
+            .OnDelete(DeleteBehavior.Restrict);
+
         builder.Property(x => x.PriceSource).HasMaxLength(50);
     }
 }
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/SalesReturnConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/SalesReturnConfiguration.cs
index f6d0c34..b569eec 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/SalesReturnConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/SalesReturnConfiguration.cs
@@ -37,5 +37,20 @@ public sealed class SalesReturnLineConfiguration : IEntityTypeConfiguration<Sale
         builder.HasOne(l => l.Return).WithMany(r => r.Lines).HasForeignKey(l => l.ReturnId).OnDelete(DeleteBehavior.Cascade);
         builder.HasOne(l => l.SalesInvoiceLine).WithMany().HasForeignKey(l => l.SalesInvoiceLineId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(l => l.Item).WithMany().HasForeignKey(l => l.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(l => l.Batch).WithMany().HasForeignKey(l => l.BatchId).OnDelete(DeleteBehavior.Restrict);
+    }
+}
+
+public sealed class SalesReturnLineSerialConfiguration : IEntityTypeConfiguration<SalesReturnLineSerial>
+{
+    public void Configure(EntityTypeBuilder<SalesReturnLineSerial> builder)
+    {
+        builder.ToTable("sales_return_line_serials");
+        builder.HasKey(s => s.SalesReturnLineSerialId);
+
+        builder.HasOne(s => s.ReturnLine).WithMany(l => l.Serials).HasForeignKey(s => s.ReturnLineId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasOne(s => s.Serial).WithMany().HasForeignKey(s => s.SerialId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(s => new { s.ReturnLineId, s.SerialId }).IsUnique();
     }
 }
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/SalesSlipConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/SalesSlipConfiguration.cs
index 73e8184..5abd308 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/SalesSlipConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/SalesSlipConfiguration.cs
@@ -38,7 +38,7 @@ public sealed class SalesSlipConfiguration : IEntityTypeConfiguration<SalesSlip>
             .HasConversion<string>().HasMaxLength(20).IsRequired()
             .HasDefaultValue(SalesSlipStatus.Draft);
 
-        foreach (var p in new[] { nameof(SalesSlip.Subtotal), nameof(SalesSlip.DiscountTotal), nameof(SalesSlip.TaxTotal), nameof(SalesSlip.GrandTotal), nameof(SalesSlip.PaidAmount), nameof(SalesSlip.BalanceAmount) })
+        foreach (var p in new[] { nameof(SalesSlip.Subtotal), nameof(SalesSlip.DiscountTotal), nameof(SalesSlip.TaxTotal), nameof(SalesSlip.GrandTotal), nameof(SalesSlip.PaidAmount), nameof(SalesSlip.BalanceAmount), nameof(SalesSlip.CashAmount), nameof(SalesSlip.CardAmount) })
             builder.Property<decimal>(p).HasPrecision(18, 4);
 
         builder.Property(x => x.CreatedAt).IsRequired();
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/StockAdjustmentConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/StockAdjustmentConfiguration.cs
index 549b0af..e290779 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/StockAdjustmentConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/StockAdjustmentConfiguration.cs
@@ -14,9 +14,12 @@ public sealed class StockAdjustmentConfiguration : IEntityTypeConfiguration<Stoc
         builder.Property(a => a.DocNo).IsRequired().HasMaxLength(30);
         builder.HasIndex(a => a.DocNo).IsUnique();
 
-        builder.Property(a => a.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
+        // 30, not 20: "PendingSecondApproval" is 21 characters.
+        builder.Property(a => a.Status).HasConversion<string>().HasMaxLength(30).IsRequired();
         builder.Property(a => a.CreatedAt).IsRequired();
         builder.Property(a => a.GlJournalNo).HasMaxLength(30);
+        builder.Property(a => a.RejectReason).HasMaxLength(250);
+        builder.HasIndex(a => a.Status);
 
         builder.HasOne(a => a.Warehouse).WithMany().HasForeignKey(a => a.WarehouseId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(a => a.ReasonCode).WithMany().HasForeignKey(a => a.ReasonCodeId).OnDelete(DeleteBehavior.Restrict);
@@ -35,11 +38,13 @@ public sealed class StockAdjustmentLineConfiguration : IEntityTypeConfiguration<
         builder.HasKey(l => l.AdjLineId);
 
         builder.Property(l => l.QtyDelta).HasPrecision(18, 4);
+        builder.Property(l => l.RequestedSerialIds).HasMaxLength(4000);
+        builder.Property(l => l.RequestedSerialNos).HasMaxLength(4000);
 
         builder.HasOne(l => l.Adjustment).WithMany(a => a.Lines).HasForeignKey(l => l.AdjustmentId).OnDelete(DeleteBehavior.Cascade);
         builder.HasOne(l => l.Item).WithMany().HasForeignKey(l => l.ItemId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne<Bin>().WithMany().HasForeignKey(l => l.BinId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne<Batch>().WithMany().HasForeignKey(l => l.BatchId).OnDelete(DeleteBehavior.Restrict);
-        builder.HasOne<Serial>().WithMany().HasForeignKey(l => l.SerialId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(l => l.Serial).WithMany().HasForeignKey(l => l.SerialId).OnDelete(DeleteBehavior.Restrict);
     }
 }
diff --git a/Backend/ERPCore/Infra/Persistence/Configurations/SubNavItemConfiguration.cs b/Backend/ERPCore/Infra/Persistence/Configurations/SubNavItemConfiguration.cs
index 5ce6c9e..a345cba 100644
--- a/Backend/ERPCore/Infra/Persistence/Configurations/SubNavItemConfiguration.cs
+++ b/Backend/ERPCore/Infra/Persistence/Configurations/SubNavItemConfiguration.cs
@@ -32,17 +32,20 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             new SubNavItem { SubNavItemId = 5, NavItemId = 2, Code = "products.uom", Label = "UOM", Href = "/dashboard/products/uoms", SortOrder = 5 },
             new SubNavItem { SubNavItemId = 6, NavItemId = 2, Code = "products.configuration", Label = "Configuration", Href = "/dashboard/products/settings", SortOrder = 6 },
             new SubNavItem { SubNavItemId = 43, NavItemId = 2, Code = "products.tax-rates", Label = "Tax Rates", Href = "/dashboard/products/tax-rates", SortOrder = 7 },
+            new SubNavItem { SubNavItemId = 48, NavItemId = 2, Code = "products.price-adjustments", Label = "Price Adjustments", Href = "/dashboard/products/price-adjustments", SortOrder = 8 },
             new SubNavItem { SubNavItemId = 29, NavItemId = 9, Code = "settings.branches", Label = "Branches", Href = "/dashboard/settings/branches", SortOrder = 0 },
             new SubNavItem { SubNavItemId = 7, NavItemId = 9, Code = "settings.roles", Label = "Roles", Href = "/dashboard/settings/roles", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 8, NavItemId = 9, Code = "settings.users", Label = "Users", Href = "/dashboard/settings/users", SortOrder = 2 },
             new SubNavItem { SubNavItemId = 24, NavItemId = 9, Code = "settings.notification-config", Label = "Notification Config", Href = "/dashboard/settings/notification-config", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 49, NavItemId = 9, Code = "settings.approvals", Label = "Approvals", Href = "/dashboard/settings/approvals", SortOrder = 4 },
             // Sales (NavItemId 13) children — mirror the sidebar order (AppSidebar.tsx). SubNavItemId
             // 23 is renamed in place (was "sales.bundle-sales" / Bundle Sales) rather than
             // delete+recreate, so any role already granted this permission keeps it; the rest are new.
             new SubNavItem { SubNavItemId = 40, NavItemId = 13, Code = "sales.invoices", Label = "Sales", Href = "/dashboard/sales/invoices", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 23, NavItemId = 13, Code = "sales.bundle-templates", Label = "Bundle Templates", Href = "/dashboard/sales/bundles/templates", SortOrder = 2 },
             new SubNavItem { SubNavItemId = 41, NavItemId = 13, Code = "sales.free-issues", Label = "Free Issues", Href = "/dashboard/sales/free-issues", SortOrder = 3 },
-            new SubNavItem { SubNavItemId = 42, NavItemId = 13, Code = "sales.day-end", Label = "Day End", Href = "/dashboard/sales/day-end", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 42, NavItemId = 13, Code = "sales.day-end", Label = "Approved Invoices", Href = "/dashboard/sales/day-end", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 46, NavItemId = 13, Code = "sales.day-end-report", Label = "Day-End Report", Href = "/dashboard/sales/day-end-report", SortOrder = 5 },
             // Procurement (NavItemId 4) children — mirror the hub page order.
             // IDs 17-20 (not 9-12): 9-12 were already claimed by the Ledgers sub-items below;
             // these procurement rows were never actually migrated into the database before now.
@@ -67,6 +70,9 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             new SubNavItem { SubNavItemId = 15, NavItemId = 12, Code = "accounts.bank-accounts", Label = "Cash / Bank Accounts", Href = "/dashboard/accounts/bank-accounts", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 21, NavItemId = 12, Code = "accounts.cheque-books", Label = "Cheque Books", Href = "/dashboard/accounts/cheque-books", SortOrder = 2 },
             new SubNavItem { SubNavItemId = 22, NavItemId = 12, Code = "accounts.received-cheques", Label = "Received Cheques", Href = "/dashboard/accounts/received-cheques", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 44, NavItemId = 12, Code = "accounts.expenses", Label = "Expenses", Href = "/dashboard/accounts/expenses", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 45, NavItemId = 12, Code = "accounts.expense-setup", Label = "Expense Setup", Href = "/dashboard/accounts/expense-setup", SortOrder = 5 },
+            new SubNavItem { SubNavItemId = 47, NavItemId = 12, Code = "accounts.bank-deposits", Label = "Bank Deposits", Href = "/dashboard/accounts/bank-deposits", SortOrder = 6 },
             // Production (NavItemId 14) children — mirror the sidebar order (AppSidebar.tsx).
             // ID 27 (not 24): 24 collides with settings.notification-config above — that ID was
             // reused by mistake in migration 20260820100345, which upserts row 24 to become the
diff --git a/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs b/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs
index fef8e6e..7b6b31e 100644
--- a/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs
+++ b/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs
@@ -90,9 +90,33 @@ public class ErpDbContext : DbContext
     public DbSet<PurchaseInvoiceLine> PurchaseInvoiceLines => Set<PurchaseInvoiceLine>();
     public DbSet<PurchaseInvoicePayment> PurchaseInvoicePayments => Set<PurchaseInvoicePayment>();
 
+    // --- Accounts: expenses (docs/EXPENSE_MODULE_PLAN.md) ---
+    public DbSet<ExpenseCategory> ExpenseCategories => Set<ExpenseCategory>();
+    public DbSet<ExpenseTitle> ExpenseTitles => Set<ExpenseTitle>();
+    public DbSet<Expense> Expenses => Set<Expense>();
+    public DbSet<ExpensePayment> ExpensePayments => Set<ExpensePayment>();
+
+    // --- Accounts: bank deposits of till cash (docs/BANK_DEPOSIT_MODULE_PLAN.md) ---
+    public DbSet<BankDeposit> BankDeposits => Set<BankDeposit>();
+
+    // --- Dual approval: stock & price adjustments (docs/DUAL_APPROVAL_PLAN.md) ---
+    public DbSet<DocumentApproval> DocumentApprovals => Set<DocumentApproval>();
+    public DbSet<ApprovalConfig> ApprovalConfig => Set<ApprovalConfig>();
+    public DbSet<PriceAdjustment> PriceAdjustments => Set<PriceAdjustment>();
+    public DbSet<PriceAdjustmentLine> PriceAdjustmentLines => Set<PriceAdjustmentLine>();
+    public DbSet<ItemPriceHistory> ItemPriceHistory => Set<ItemPriceHistory>();
+
     // --- Batch / Serial (docs/10 Part C.4) ---
     public DbSet<Batch> Batches => Set<Batch>();
     public DbSet<Serial> Serials => Set<Serial>();
+    public DbSet<GrnLineSerial> GrnLineSerials => Set<GrnLineSerial>();
+    public DbSet<SalesInvoiceLineSerial> SalesInvoiceLineSerials => Set<SalesInvoiceLineSerial>();
+    public DbSet<SalesSlipLineSerial> SalesSlipLineSerials => Set<SalesSlipLineSerial>();
+    public DbSet<SalesLineAllocation> SalesLineAllocations => Set<SalesLineAllocation>();
+    public DbSet<WarrantyRegistration> WarrantyRegistrations => Set<WarrantyRegistration>();
+    public DbSet<SalesReturnLineSerial> SalesReturnLineSerials => Set<SalesReturnLineSerial>();
+    public DbSet<SerialMovement> SerialMovements => Set<SerialMovement>();
+    public DbSet<StockTransferLineSerial> StockTransferLineSerials => Set<StockTransferLineSerial>();
 
     // --- Stock core: FIFO layers + immutable ledger (docs/10 Part C.5) ---
     public DbSet<StockLayer> StockLayers => Set<StockLayer>();
@@ -213,6 +237,8 @@ public class ErpDbContext : DbContext
         modelBuilder.Entity<Rfq>().HasQueryFilter(e => !_currentBranch.IsActive || e.BranchId == _currentBranch.BranchId);
         modelBuilder.Entity<PurchaseOrder>().HasQueryFilter(e => !_currentBranch.IsActive || e.BranchId == _currentBranch.BranchId);
         modelBuilder.Entity<PurchaseInvoice>().HasQueryFilter(e => !_currentBranch.IsActive || e.BranchId == _currentBranch.BranchId);
+        modelBuilder.Entity<Expense>().HasQueryFilter(e => !_currentBranch.IsActive || e.BranchId == _currentBranch.BranchId);
+        modelBuilder.Entity<BankDeposit>().HasQueryFilter(e => !_currentBranch.IsActive || e.BranchId == _currentBranch.BranchId);
 
         // Optimistic concurrency token. On PostgreSQL this was the virtual `xmin` system
         // column via .IsRowVersion(), which the engine maintained for free. MariaDB has no
diff --git a/Backend/ERPCore/Migrations/20261007054513_AddItemTrackingSerialsWarranty.Designer.cs b/Backend/ERPCore/Migrations/20261007054513_AddItemTrackingSerialsWarranty.Designer.cs
new file mode 100644
index 0000000..6b767ef
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261007054513_AddItemTrackingSerialsWarranty.Designer.cs
@@ -0,0 +1,9481 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261007054513_AddItemTrackingSerialsWarranty")]
+    partial class AddItemTrackingSerialsWarranty
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Day End",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261007054513_AddItemTrackingSerialsWarranty.cs b/Backend/ERPCore/Migrations/20261007054513_AddItemTrackingSerialsWarranty.cs
new file mode 100644
index 0000000..b8236d3
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261007054513_AddItemTrackingSerialsWarranty.cs
@@ -0,0 +1,635 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddItemTrackingSerialsWarranty : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "BinId",
+                table: "serials",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "serials",
+                type: "datetime(6)",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+
+            migrationBuilder.AddColumn<int>(
+                name: "GrnLineId",
+                table: "serials",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "ReceivedAt",
+                table: "serials",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<uint>(
+                name: "RowVersion",
+                table: "serials",
+                type: "int unsigned",
+                nullable: false,
+                defaultValue: 0u);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "UpdatedAt",
+                table: "serials",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "WarehouseId",
+                table: "serials",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "WarrantyPeriodMonths",
+                table: "serials",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "BatchId",
+                table: "sales_return_lines",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "BatchId",
+                table: "sales_invoice_lines",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "grn_line_serials",
+                columns: table => new
+                {
+                    GrnLineSerialId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    GrnLineId = table.Column<int>(type: "int", nullable: false),
+                    SerialNo = table.Column<string>(type: "varchar(100)", maxLength: 100, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    SerialId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_grn_line_serials", x => x.GrnLineSerialId);
+                    table.ForeignKey(
+                        name: "FK_grn_line_serials_grn_lines_GrnLineId",
+                        column: x => x.GrnLineId,
+                        principalTable: "grn_lines",
+                        principalColumn: "GrnLineId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_grn_line_serials_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "sales_invoice_line_serials",
+                columns: table => new
+                {
+                    SalesInvoiceLineSerialId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    SalesInvoiceLineId = table.Column<int>(type: "int", nullable: false),
+                    SerialId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_invoice_line_serials", x => x.SalesInvoiceLineSerialId);
+                    table.ForeignKey(
+                        name: "FK_sales_invoice_line_serials_sales_invoice_lines_SalesInvoiceL~",
+                        column: x => x.SalesInvoiceLineId,
+                        principalTable: "sales_invoice_lines",
+                        principalColumn: "SalesInvoiceLineId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_sales_invoice_line_serials_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "sales_line_allocations",
+                columns: table => new
+                {
+                    SalesLineAllocationId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    SourceDocType = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    SourceDocId = table.Column<int>(type: "int", nullable: false),
+                    SourceLineId = table.Column<int>(type: "int", nullable: false),
+                    ItemId = table.Column<int>(type: "int", nullable: false),
+                    WarehouseId = table.Column<int>(type: "int", nullable: false),
+                    BatchId = table.Column<int>(type: "int", nullable: true),
+                    SerialId = table.Column<int>(type: "int", nullable: true),
+                    Qty = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    UnitCost = table.Column<decimal>(type: "decimal(18,6)", precision: 18, scale: 6, nullable: false),
+                    QtyReturned = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_line_allocations", x => x.SalesLineAllocationId);
+                    table.ForeignKey(
+                        name: "FK_sales_line_allocations_batches_BatchId",
+                        column: x => x.BatchId,
+                        principalTable: "batches",
+                        principalColumn: "BatchId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_line_allocations_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "sales_return_line_serials",
+                columns: table => new
+                {
+                    SalesReturnLineSerialId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    ReturnLineId = table.Column<int>(type: "int", nullable: false),
+                    SerialId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_return_line_serials", x => x.SalesReturnLineSerialId);
+                    table.ForeignKey(
+                        name: "FK_sales_return_line_serials_sales_return_lines_ReturnLineId",
+                        column: x => x.ReturnLineId,
+                        principalTable: "sales_return_lines",
+                        principalColumn: "ReturnLineId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_sales_return_line_serials_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "sales_slip_line_serials",
+                columns: table => new
+                {
+                    SalesSlipLineSerialId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    SalesSlipLineId = table.Column<int>(type: "int", nullable: false),
+                    SerialId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_slip_line_serials", x => x.SalesSlipLineSerialId);
+                    table.ForeignKey(
+                        name: "FK_sales_slip_line_serials_sales_slip_lines_SalesSlipLineId",
+                        column: x => x.SalesSlipLineId,
+                        principalTable: "sales_slip_lines",
+                        principalColumn: "SalesSlipLineId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_sales_slip_line_serials_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "serial_movements",
+                columns: table => new
+                {
+                    SerialMovementId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    SerialId = table.Column<int>(type: "int", nullable: false),
+                    SourceDocType = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    SourceDocId = table.Column<int>(type: "int", nullable: false),
+                    Status = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    FromWarehouseId = table.Column<int>(type: "int", nullable: true),
+                    WarehouseId = table.Column<int>(type: "int", nullable: true),
+                    UserId = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_serial_movements", x => x.SerialMovementId);
+                    table.ForeignKey(
+                        name: "FK_serial_movements_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Cascade);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "stock_transfer_line_serials",
+                columns: table => new
+                {
+                    StockTransferLineSerialId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    TransferLineId = table.Column<int>(type: "int", nullable: false),
+                    SerialId = table.Column<int>(type: "int", nullable: false),
+                    BatchId = table.Column<int>(type: "int", nullable: true),
+                    UnitCost = table.Column<decimal>(type: "decimal(18,6)", precision: 18, scale: 6, nullable: true),
+                    ReceivedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_stock_transfer_line_serials", x => x.StockTransferLineSerialId);
+                    table.ForeignKey(
+                        name: "FK_stock_transfer_line_serials_batches_BatchId",
+                        column: x => x.BatchId,
+                        principalTable: "batches",
+                        principalColumn: "BatchId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_stock_transfer_line_serials_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_stock_transfer_line_serials_stock_transfer_lines_TransferLin~",
+                        column: x => x.TransferLineId,
+                        principalTable: "stock_transfer_lines",
+                        principalColumn: "TransferLineId",
+                        onDelete: ReferentialAction.Cascade);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "warranty_registrations",
+                columns: table => new
+                {
+                    WarrantyRegistrationId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    ItemId = table.Column<int>(type: "int", nullable: false),
+                    SerialId = table.Column<int>(type: "int", nullable: true),
+                    CustomerId = table.Column<int>(type: "int", nullable: false),
+                    SourceDocType = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    SourceDocId = table.Column<int>(type: "int", nullable: false),
+                    SourceLineId = table.Column<int>(type: "int", nullable: false),
+                    Qty = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    StartDate = table.Column<DateOnly>(type: "date", nullable: false),
+                    PeriodMonths = table.Column<int>(type: "int", nullable: false),
+                    EndDate = table.Column<DateOnly>(type: "date", nullable: false),
+                    Status = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_warranty_registrations", x => x.WarrantyRegistrationId);
+                    table.ForeignKey(
+                        name: "FK_warranty_registrations_customers_CustomerId",
+                        column: x => x.CustomerId,
+                        principalTable: "customers",
+                        principalColumn: "CustomerId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_warranty_registrations_items_ItemId",
+                        column: x => x.ItemId,
+                        principalTable: "items",
+                        principalColumn: "ItemId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_warranty_registrations_serials_SerialId",
+                        column: x => x.SerialId,
+                        principalTable: "serials",
+                        principalColumn: "SerialId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_serials_BinId",
+                table: "serials",
+                column: "BinId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_serials_GrnLineId",
+                table: "serials",
+                column: "GrnLineId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_serials_ItemId_Status",
+                table: "serials",
+                columns: new[] { "ItemId", "Status" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_serials_WarehouseId_ItemId_Status",
+                table: "serials",
+                columns: new[] { "WarehouseId", "ItemId", "Status" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_return_lines_BatchId",
+                table: "sales_return_lines",
+                column: "BatchId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_invoice_lines_BatchId",
+                table: "sales_invoice_lines",
+                column: "BatchId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_line_serials_GrnLineId_SerialNo",
+                table: "grn_line_serials",
+                columns: new[] { "GrnLineId", "SerialNo" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_line_serials_SerialId",
+                table: "grn_line_serials",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_invoice_line_serials_SalesInvoiceLineId_SerialId",
+                table: "sales_invoice_line_serials",
+                columns: new[] { "SalesInvoiceLineId", "SerialId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_invoice_line_serials_SerialId",
+                table: "sales_invoice_line_serials",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_line_allocations_BatchId",
+                table: "sales_line_allocations",
+                column: "BatchId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_line_allocations_SerialId",
+                table: "sales_line_allocations",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_line_allocations_SourceDocType_SourceDocId_SourceLineId",
+                table: "sales_line_allocations",
+                columns: new[] { "SourceDocType", "SourceDocId", "SourceLineId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_return_line_serials_ReturnLineId_SerialId",
+                table: "sales_return_line_serials",
+                columns: new[] { "ReturnLineId", "SerialId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_return_line_serials_SerialId",
+                table: "sales_return_line_serials",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_slip_line_serials_SalesSlipLineId_SerialId",
+                table: "sales_slip_line_serials",
+                columns: new[] { "SalesSlipLineId", "SerialId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_slip_line_serials_SerialId",
+                table: "sales_slip_line_serials",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_serial_movements_SerialId_SerialMovementId",
+                table: "serial_movements",
+                columns: new[] { "SerialId", "SerialMovementId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_serial_movements_SourceDocType_SourceDocId",
+                table: "serial_movements",
+                columns: new[] { "SourceDocType", "SourceDocId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_stock_transfer_line_serials_BatchId",
+                table: "stock_transfer_line_serials",
+                column: "BatchId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_stock_transfer_line_serials_SerialId",
+                table: "stock_transfer_line_serials",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_stock_transfer_line_serials_TransferLineId_SerialId",
+                table: "stock_transfer_line_serials",
+                columns: new[] { "TransferLineId", "SerialId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_warranty_registrations_CustomerId",
+                table: "warranty_registrations",
+                column: "CustomerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_warranty_registrations_ItemId",
+                table: "warranty_registrations",
+                column: "ItemId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_warranty_registrations_SerialId",
+                table: "warranty_registrations",
+                column: "SerialId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_warranty_registrations_SourceDocType_SourceDocId",
+                table: "warranty_registrations",
+                columns: new[] { "SourceDocType", "SourceDocId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_warranty_registrations_Status_EndDate",
+                table: "warranty_registrations",
+                columns: new[] { "Status", "EndDate" });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_sales_invoice_lines_batches_BatchId",
+                table: "sales_invoice_lines",
+                column: "BatchId",
+                principalTable: "batches",
+                principalColumn: "BatchId",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_sales_return_lines_batches_BatchId",
+                table: "sales_return_lines",
+                column: "BatchId",
+                principalTable: "batches",
+                principalColumn: "BatchId",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_serials_bins_BinId",
+                table: "serials",
+                column: "BinId",
+                principalTable: "bins",
+                principalColumn: "BinId",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_serials_grn_lines_GrnLineId",
+                table: "serials",
+                column: "GrnLineId",
+                principalTable: "grn_lines",
+                principalColumn: "GrnLineId",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_serials_warehouses_WarehouseId",
+                table: "serials",
+                column: "WarehouseId",
+                principalTable: "warehouses",
+                principalColumn: "WarehouseId",
+                onDelete: ReferentialAction.Restrict);
+
+            // Backfill serial rows that predate this migration: a real CreatedAt, a live
+            // concurrency token (0 is never live — see ErpDbContext.BumpRowVersions), and the
+            // warehouse of an in-stock serial's own open layer, if it has one.
+            migrationBuilder.Sql("""
+                UPDATE `serials` SET `CreatedAt` = UTC_TIMESTAMP(6) WHERE `CreatedAt` < '1900-01-01';
+                UPDATE `serials` SET `RowVersion` = 1 WHERE `RowVersion` = 0;
+                UPDATE `serials` s
+                  JOIN `stock_layers` l ON l.`SerialId` = s.`SerialId` AND l.`QtyRemaining` > 0
+                   SET s.`WarehouseId` = l.`WarehouseId`
+                 WHERE s.`Status` = 'InStock' AND s.`WarehouseId` IS NULL;
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_sales_invoice_lines_batches_BatchId",
+                table: "sales_invoice_lines");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_sales_return_lines_batches_BatchId",
+                table: "sales_return_lines");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_serials_bins_BinId",
+                table: "serials");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_serials_grn_lines_GrnLineId",
+                table: "serials");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_serials_warehouses_WarehouseId",
+                table: "serials");
+
+            migrationBuilder.DropTable(
+                name: "grn_line_serials");
+
+            migrationBuilder.DropTable(
+                name: "sales_invoice_line_serials");
+
+            migrationBuilder.DropTable(
+                name: "sales_line_allocations");
+
+            migrationBuilder.DropTable(
+                name: "sales_return_line_serials");
+
+            migrationBuilder.DropTable(
+                name: "sales_slip_line_serials");
+
+            migrationBuilder.DropTable(
+                name: "serial_movements");
+
+            migrationBuilder.DropTable(
+                name: "stock_transfer_line_serials");
+
+            migrationBuilder.DropTable(
+                name: "warranty_registrations");
+
+            migrationBuilder.DropIndex(
+                name: "IX_serials_BinId",
+                table: "serials");
+
+            migrationBuilder.DropIndex(
+                name: "IX_serials_GrnLineId",
+                table: "serials");
+
+            migrationBuilder.DropIndex(
+                name: "IX_serials_ItemId_Status",
+                table: "serials");
+
+            migrationBuilder.DropIndex(
+                name: "IX_serials_WarehouseId_ItemId_Status",
+                table: "serials");
+
+            migrationBuilder.DropIndex(
+                name: "IX_sales_return_lines_BatchId",
+                table: "sales_return_lines");
+
+            migrationBuilder.DropIndex(
+                name: "IX_sales_invoice_lines_BatchId",
+                table: "sales_invoice_lines");
+
+            migrationBuilder.DropColumn(
+                name: "BinId",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "GrnLineId",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "ReceivedAt",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "RowVersion",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "UpdatedAt",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "WarehouseId",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "WarrantyPeriodMonths",
+                table: "serials");
+
+            migrationBuilder.DropColumn(
+                name: "BatchId",
+                table: "sales_return_lines");
+
+            migrationBuilder.DropColumn(
+                name: "BatchId",
+                table: "sales_invoice_lines");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261007094000_AddExpenseModule.Designer.cs b/Backend/ERPCore/Migrations/20261007094000_AddExpenseModule.Designer.cs
new file mode 100644
index 0000000..2e08d9d
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261007094000_AddExpenseModule.Designer.cs
@@ -0,0 +1,10153 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261007094000_AddExpenseModule")]
+    partial class AddExpenseModule
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "6200",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "6200",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "6200",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Day End",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261007094000_AddExpenseModule.cs b/Backend/ERPCore/Migrations/20261007094000_AddExpenseModule.cs
new file mode 100644
index 0000000..a0c7891
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261007094000_AddExpenseModule.cs
@@ -0,0 +1,336 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddExpenseModule : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "expense_categories",
+                columns: table => new
+                {
+                    ExpenseCategoryId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    Code = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    Name = table.Column<string>(type: "varchar(100)", maxLength: 100, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    IsSystem = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    Status = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, defaultValue: "Active", collation: "utf8mb4_unicode_ci"),
+                    SortOrder = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_expense_categories", x => x.ExpenseCategoryId);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "expense_titles",
+                columns: table => new
+                {
+                    ExpenseTitleId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    ExpenseCategoryId = table.Column<int>(type: "int", nullable: false),
+                    Name = table.Column<string>(type: "varchar(100)", maxLength: 100, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    GlExpenseAccountCode = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    IsSystem = table.Column<bool>(type: "tinyint(1)", nullable: false),
+                    Status = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, defaultValue: "Active", collation: "utf8mb4_unicode_ci"),
+                    SortOrder = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_expense_titles", x => x.ExpenseTitleId);
+                    table.ForeignKey(
+                        name: "FK_expense_titles_expense_categories_ExpenseCategoryId",
+                        column: x => x.ExpenseCategoryId,
+                        principalTable: "expense_categories",
+                        principalColumn: "ExpenseCategoryId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "expenses",
+                columns: table => new
+                {
+                    ExpenseId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    DocNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    BranchId = table.Column<int>(type: "int", nullable: false),
+                    ExpenseDate = table.Column<DateOnly>(type: "date", nullable: false),
+                    DueDate = table.Column<DateOnly>(type: "date", nullable: true),
+                    ExpenseCategoryId = table.Column<int>(type: "int", nullable: false),
+                    ExpenseTitleId = table.Column<int>(type: "int", nullable: false),
+                    Payee = table.Column<string>(type: "varchar(150)", maxLength: 150, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    VendorId = table.Column<int>(type: "int", nullable: true),
+                    BillReference = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    Description = table.Column<string>(type: "varchar(500)", maxLength: 500, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    PeriodMonth = table.Column<string>(type: "varchar(7)", maxLength: 7, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    Amount = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    PaidAmount = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    BalanceAmount = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    Status = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, defaultValue: "Draft", collation: "utf8mb4_unicode_ci"),
+                    PaymentStatus = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, defaultValue: "Unpaid", collation: "utf8mb4_unicode_ci"),
+                    GlExpenseAccountCode = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    GlJournalNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    GlPostedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    GlReversalJournalNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    CancelReason = table.Column<string>(type: "varchar(250)", maxLength: 250, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    CreatedBy = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_expenses", x => x.ExpenseId);
+                    table.CheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                    table.ForeignKey(
+                        name: "FK_expenses_expense_categories_ExpenseCategoryId",
+                        column: x => x.ExpenseCategoryId,
+                        principalTable: "expense_categories",
+                        principalColumn: "ExpenseCategoryId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_expenses_expense_titles_ExpenseTitleId",
+                        column: x => x.ExpenseTitleId,
+                        principalTable: "expense_titles",
+                        principalColumn: "ExpenseTitleId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_expenses_hr_branches_BranchId",
+                        column: x => x.BranchId,
+                        principalTable: "hr_branches",
+                        principalColumn: "BranchId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_expenses_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_expenses_vendors_VendorId",
+                        column: x => x.VendorId,
+                        principalTable: "vendors",
+                        principalColumn: "VendorId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "expense_payments",
+                columns: table => new
+                {
+                    ExpensePaymentId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    ExpenseId = table.Column<int>(type: "int", nullable: false),
+                    Amount = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    PaymentDate = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    PaymentMethod = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    GlBankAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    BankAccountName = table.Column<string>(type: "varchar(200)", maxLength: 200, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    ChequeNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    Reference = table.Column<string>(type: "varchar(100)", maxLength: 100, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    GlJournalNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    CreatedBy = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_expense_payments", x => x.ExpensePaymentId);
+                    table.ForeignKey(
+                        name: "FK_expense_payments_expenses_ExpenseId",
+                        column: x => x.ExpenseId,
+                        principalTable: "expenses",
+                        principalColumn: "ExpenseId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_expense_payments_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.InsertData(
+                table: "expense_categories",
+                columns: new[] { "ExpenseCategoryId", "Code", "CreatedAt", "IsSystem", "Name", "RowVersion", "SortOrder", "UpdatedAt" },
+                values: new object[,]
+                {
+                    { 1, "UTILITY", new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), true, "Utility", 1u, 1, null },
+                    { 2, "RENTAL", new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), true, "Rental", 1u, 2, null },
+                    { 3, "SALARIES", new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), true, "Salaries", 1u, 3, null },
+                    { 4, "OTHER", new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), true, "Other", 1u, 4, null }
+                });
+
+            migrationBuilder.InsertData(
+                table: "sub_nav_items",
+                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
+                values: new object[,]
+                {
+                    { 44, "accounts.expenses", "/dashboard/accounts/expenses", null, "Expenses", 12, 4 },
+                    { 45, "accounts.expense-setup", "/dashboard/accounts/expense-setup", null, "Expense Setup", 12, 5 }
+                });
+
+            migrationBuilder.InsertData(
+                table: "expense_titles",
+                columns: new[] { "ExpenseTitleId", "CreatedAt", "ExpenseCategoryId", "GlExpenseAccountCode", "IsSystem", "Name", "RowVersion", "SortOrder", "UpdatedAt" },
+                values: new object[,]
+                {
+                    { 1, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 1, "6100", true, "Electricity", 1u, 1, null },
+                    { 2, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 1, "6100", true, "Water", 1u, 2, null },
+                    { 3, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 1, "6100", true, "Telephone", 1u, 3, null },
+                    { 4, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 1, "6100", true, "Internet", 1u, 4, null },
+                    { 5, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 1, "6100", true, "Gas", 1u, 5, null },
+                    { 6, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 2, "6200", true, "Building Rent", 1u, 1, null },
+                    { 7, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 2, "6200", true, "Vehicle Rent", 1u, 2, null },
+                    { 8, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 2, "6200", true, "Equipment Rent", 1u, 3, null },
+                    { 9, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 3, "6300", true, "Staff Salaries", 1u, 1, null },
+                    { 10, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 3, "6300", true, "Wages", 1u, 2, null },
+                    { 11, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 3, "6300", true, "Overtime", 1u, 3, null },
+                    { 12, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 3, "6300", true, "Bonus", 1u, 4, null },
+                    { 13, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 3, "6300", true, "EPF / ETF Contribution", 1u, 5, null },
+                    { 14, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 4, "6900", true, "Stationery", 1u, 1, null },
+                    { 15, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 4, "6900", true, "Transport", 1u, 2, null },
+                    { 16, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 4, "6900", true, "Repairs & Maintenance", 1u, 3, null },
+                    { 17, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 4, "6900", true, "Cleaning", 1u, 4, null },
+                    { 18, new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc), 4, "6900", true, "Miscellaneous", 1u, 5, null }
+                });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[,]
+                {
+                    { 54, "NAV:accounts.expenses", null, 44 },
+                    { 55, "NAV:accounts.expense-setup", null, 45 }
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expense_categories_Code",
+                table: "expense_categories",
+                column: "Code",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expense_categories_Name",
+                table: "expense_categories",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expense_payments_CreatedBy",
+                table: "expense_payments",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expense_payments_ExpenseId",
+                table: "expense_payments",
+                column: "ExpenseId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expense_titles_ExpenseCategoryId_Name",
+                table: "expense_titles",
+                columns: new[] { "ExpenseCategoryId", "Name" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_BranchId",
+                table: "expenses",
+                column: "BranchId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_CreatedBy",
+                table: "expenses",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_DocNo",
+                table: "expenses",
+                column: "DocNo",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_ExpenseCategoryId",
+                table: "expenses",
+                column: "ExpenseCategoryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_ExpenseDate",
+                table: "expenses",
+                column: "ExpenseDate");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_ExpenseTitleId",
+                table: "expenses",
+                column: "ExpenseTitleId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_PaymentStatus",
+                table: "expenses",
+                column: "PaymentStatus");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_Status",
+                table: "expenses",
+                column: "Status");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_expenses_VendorId",
+                table: "expenses",
+                column: "VendorId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "expense_payments");
+
+            migrationBuilder.DropTable(
+                name: "expenses");
+
+            migrationBuilder.DropTable(
+                name: "expense_titles");
+
+            migrationBuilder.DropTable(
+                name: "expense_categories");
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 54);
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 55);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 44);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 45);
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008045542_GrantExpensePermissions.Designer.cs b/Backend/ERPCore/Migrations/20261008045542_GrantExpensePermissions.Designer.cs
new file mode 100644
index 0000000..b5ffaac
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008045542_GrantExpensePermissions.Designer.cs
@@ -0,0 +1,10153 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261008045542_GrantExpensePermissions")]
+    partial class GrantExpensePermissions
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "6100",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "6200",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "6200",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "6200",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "6300",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "6900",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Day End",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008045542_GrantExpensePermissions.cs b/Backend/ERPCore/Migrations/20261008045542_GrantExpensePermissions.cs
new file mode 100644
index 0000000..54cfc9c
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008045542_GrantExpensePermissions.cs
@@ -0,0 +1,37 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <summary>
+    /// Data-only: grants the two new Accounts sub-items (NAV:accounts.expenses = 54,
+    /// NAV:accounts.expense-setup = 55, added by AddExpenseModule) to the Admin role and to every
+    /// role that already reaches Accounts (NAV:accounts 32, bank-accounts 26, cheque-books 33,
+    /// received-cheques 34). Without this no role — Admin included — has the codes in
+    /// /auth/me's navCodes, so the sidebar hides the screens. Admins can still revoke them per
+    /// role afterwards. INSERT IGNORE keeps it idempotent against grants made by hand.
+    /// </summary>
+    public partial class GrantExpensePermissions : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                INSERT IGNORE INTO `role_permissions` (`RoleId`, `PermissionId`, `Actions`)
+                SELECT r.`RoleId`, p.`PermissionId`, 31
+                FROM `roles` r
+                CROSS JOIN (SELECT 54 AS `PermissionId` UNION ALL SELECT 55) p
+                WHERE LOWER(r.`Code`) = 'admin'
+                   OR EXISTS (SELECT 1 FROM `role_permissions` rp
+                              WHERE rp.`RoleId` = r.`RoleId` AND rp.`PermissionId` IN (26, 32, 33, 34));
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("DELETE FROM `role_permissions` WHERE `PermissionId` IN (54, 55);");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008051009_UpdateExpenseGlCodes.Designer.cs b/Backend/ERPCore/Migrations/20261008051009_UpdateExpenseGlCodes.Designer.cs
new file mode 100644
index 0000000..1e1fef1
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008051009_UpdateExpenseGlCodes.Designer.cs
@@ -0,0 +1,10153 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261008051009_UpdateExpenseGlCodes")]
+    partial class UpdateExpenseGlCodes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Day End",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008051009_UpdateExpenseGlCodes.cs b/Backend/ERPCore/Migrations/20261008051009_UpdateExpenseGlCodes.cs
new file mode 100644
index 0000000..e4b739c
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008051009_UpdateExpenseGlCodes.cs
@@ -0,0 +1,270 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class UpdateExpenseGlCodes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 1,
+                column: "GlExpenseAccountCode",
+                value: "5200-01");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 2,
+                column: "GlExpenseAccountCode",
+                value: "5200-01");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 3,
+                column: "GlExpenseAccountCode",
+                value: "5200-01");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 4,
+                column: "GlExpenseAccountCode",
+                value: "5200-01");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 5,
+                column: "GlExpenseAccountCode",
+                value: "5200-01");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 6,
+                column: "GlExpenseAccountCode",
+                value: "5200-02");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 7,
+                column: "GlExpenseAccountCode",
+                value: "5200-02");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 8,
+                column: "GlExpenseAccountCode",
+                value: "5200-02");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 9,
+                column: "GlExpenseAccountCode",
+                value: "5200-03");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 10,
+                column: "GlExpenseAccountCode",
+                value: "5200-03");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 11,
+                column: "GlExpenseAccountCode",
+                value: "5200-03");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 12,
+                column: "GlExpenseAccountCode",
+                value: "5200-03");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 13,
+                column: "GlExpenseAccountCode",
+                value: "5200-03");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 14,
+                column: "GlExpenseAccountCode",
+                value: "5200-04");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 15,
+                column: "GlExpenseAccountCode",
+                value: "5200-04");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 16,
+                column: "GlExpenseAccountCode",
+                value: "5200-04");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 17,
+                column: "GlExpenseAccountCode",
+                value: "5200-04");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 18,
+                column: "GlExpenseAccountCode",
+                value: "5200-04");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 1,
+                column: "GlExpenseAccountCode",
+                value: "6100");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 2,
+                column: "GlExpenseAccountCode",
+                value: "6100");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 3,
+                column: "GlExpenseAccountCode",
+                value: "6100");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 4,
+                column: "GlExpenseAccountCode",
+                value: "6100");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 5,
+                column: "GlExpenseAccountCode",
+                value: "6100");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 6,
+                column: "GlExpenseAccountCode",
+                value: "6200");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 7,
+                column: "GlExpenseAccountCode",
+                value: "6200");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 8,
+                column: "GlExpenseAccountCode",
+                value: "6200");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 9,
+                column: "GlExpenseAccountCode",
+                value: "6300");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 10,
+                column: "GlExpenseAccountCode",
+                value: "6300");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 11,
+                column: "GlExpenseAccountCode",
+                value: "6300");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 12,
+                column: "GlExpenseAccountCode",
+                value: "6300");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 13,
+                column: "GlExpenseAccountCode",
+                value: "6300");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 14,
+                column: "GlExpenseAccountCode",
+                value: "6900");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 15,
+                column: "GlExpenseAccountCode",
+                value: "6900");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 16,
+                column: "GlExpenseAccountCode",
+                value: "6900");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 17,
+                column: "GlExpenseAccountCode",
+                value: "6900");
+
+            migrationBuilder.UpdateData(
+                table: "expense_titles",
+                keyColumn: "ExpenseTitleId",
+                keyValue: 18,
+                column: "GlExpenseAccountCode",
+                value: "6900");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008055041_RenameDayEndToApprovedInvoices.Designer.cs b/Backend/ERPCore/Migrations/20261008055041_RenameDayEndToApprovedInvoices.Designer.cs
new file mode 100644
index 0000000..3ec146a
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008055041_RenameDayEndToApprovedInvoices.Designer.cs
@@ -0,0 +1,10153 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261008055041_RenameDayEndToApprovedInvoices")]
+    partial class RenameDayEndToApprovedInvoices
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Approved Invoices",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008055041_RenameDayEndToApprovedInvoices.cs b/Backend/ERPCore/Migrations/20261008055041_RenameDayEndToApprovedInvoices.cs
new file mode 100644
index 0000000..cec3c56
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008055041_RenameDayEndToApprovedInvoices.cs
@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class RenameDayEndToApprovedInvoices : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 42,
+                column: "Label",
+                value: "Approved Invoices");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 42,
+                column: "Label",
+                value: "Day End");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008061111_AddSalesPaymentMethodsAndDayEndReport.Designer.cs b/Backend/ERPCore/Migrations/20261008061111_AddSalesPaymentMethodsAndDayEndReport.Designer.cs
new file mode 100644
index 0000000..ed17921
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008061111_AddSalesPaymentMethodsAndDayEndReport.Designer.cs
@@ -0,0 +1,10192 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261008061111_AddSalesPaymentMethodsAndDayEndReport")]
+    partial class AddSalesPaymentMethodsAndDayEndReport
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        },
+                        new
+                        {
+                            PermissionId = 56,
+                            Code = "NAV:sales.day-end-report",
+                            SubNavItemId = 46
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Cash");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Approved Invoices",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 46,
+                            Code = "sales.day-end-report",
+                            Href = "/dashboard/sales/day-end-report",
+                            Label = "Day-End Report",
+                            NavItemId = 13,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008061111_AddSalesPaymentMethodsAndDayEndReport.cs b/Backend/ERPCore/Migrations/20261008061111_AddSalesPaymentMethodsAndDayEndReport.cs
new file mode 100644
index 0000000..9e37a0b
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008061111_AddSalesPaymentMethodsAndDayEndReport.cs
@@ -0,0 +1,123 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSalesPaymentMethodsAndDayEndReport : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<decimal>(
+                name: "CardAmount",
+                table: "sales_slips",
+                type: "decimal(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "CashAmount",
+                table: "sales_slips",
+                type: "decimal(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<string>(
+                name: "PaymentMethod",
+                table: "sales_invoice_payments",
+                type: "varchar(20)",
+                maxLength: 20,
+                nullable: false,
+                defaultValue: "Cash",
+                collation: "utf8mb4_unicode_ci");
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "CardAmount",
+                table: "bundle_sales",
+                type: "decimal(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "CashAmount",
+                table: "bundle_sales",
+                type: "decimal(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.InsertData(
+                table: "sub_nav_items",
+                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
+                values: new object[] { 46, "sales.day-end-report", "/dashboard/sales/day-end-report", null, "Day-End Report", 13, 5 });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[] { 56, "NAV:sales.day-end-report", null, 46 });
+
+            // Every sale before the cash/card split existed was treated as cash (see SalesDayEnd's
+            // PaidTotal), so existing slips/bundles are all cash; invoice payments already default
+            // to 'Cash' through the column default above.
+            migrationBuilder.Sql("UPDATE `sales_slips` SET `CashAmount` = `PaidAmount`, `CardAmount` = 0;");
+            migrationBuilder.Sql("UPDATE `bundle_sales` SET `CashAmount` = `GrandTotal`, `CardAmount` = 0;");
+
+            // Grant the new report (56) to Admin and to every role that already reaches the
+            // cashier close-out (NAV:sales.day-end = 52) — it shows income, so it follows the
+            // close-out rather than plain invoicing. Same idempotent pattern as GrantExpensePermissions.
+            migrationBuilder.Sql("""
+                INSERT IGNORE INTO `role_permissions` (`RoleId`, `PermissionId`, `Actions`)
+                SELECT r.`RoleId`, 56, 31
+                FROM `roles` r
+                WHERE LOWER(r.`Code`) = 'admin'
+                   OR EXISTS (SELECT 1 FROM `role_permissions` rp
+                              WHERE rp.`RoleId` = r.`RoleId` AND rp.`PermissionId` = 52);
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("DELETE FROM `role_permissions` WHERE `PermissionId` = 56;");
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 56);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 46);
+
+            migrationBuilder.DropColumn(
+                name: "CardAmount",
+                table: "sales_slips");
+
+            migrationBuilder.DropColumn(
+                name: "CashAmount",
+                table: "sales_slips");
+
+            migrationBuilder.DropColumn(
+                name: "PaymentMethod",
+                table: "sales_invoice_payments");
+
+            migrationBuilder.DropColumn(
+                name: "CardAmount",
+                table: "bundle_sales");
+
+            migrationBuilder.DropColumn(
+                name: "CashAmount",
+                table: "bundle_sales");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008072141_AddBankDepositModule.Designer.cs b/Backend/ERPCore/Migrations/20261008072141_AddBankDepositModule.Designer.cs
new file mode 100644
index 0000000..f137479
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008072141_AddBankDepositModule.Designer.cs
@@ -0,0 +1,10354 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261008072141_AddBankDepositModule")]
+    partial class AddBankDepositModule
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.Property<int>("BankDepositId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BankDepositId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("CancelledBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("DepositDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("DepositSlipNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("DepositedBy")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FromCashAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("FromCashAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<long>("FromGlCashAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("Remarks")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Posted");
+
+                    b.Property<string>("ToAccountNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("ToBankAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ToBankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ToBankName")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<long>("ToGlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("BankDepositId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ToGlBankAccountId");
+
+                    b.HasIndex("BranchId", "BusinessDate", "Status");
+
+                    b.ToTable("bank_deposits", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_bank_deposits_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        },
+                        new
+                        {
+                            PermissionId = 56,
+                            Code = "NAV:sales.day-end-report",
+                            SubNavItemId = 46
+                        },
+                        new
+                        {
+                            PermissionId = 57,
+                            Code = "NAV:accounts.bank-deposits",
+                            SubNavItemId = 47
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Cash");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Approved Invoices",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 46,
+                            Code = "sales.day-end-report",
+                            Href = "/dashboard/sales/day-end-report",
+                            Label = "Day-End Report",
+                            NavItemId = 13,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 47,
+                            Code = "accounts.bank-deposits",
+                            Href = "/dashboard/accounts/bank-deposits",
+                            Label = "Bank Deposits",
+                            NavItemId = 12,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261008072141_AddBankDepositModule.cs b/Backend/ERPCore/Migrations/20261008072141_AddBankDepositModule.cs
new file mode 100644
index 0000000..351b937
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261008072141_AddBankDepositModule.cs
@@ -0,0 +1,131 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBankDepositModule : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "bank_deposits",
+                columns: table => new
+                {
+                    BankDepositId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    DocNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    BranchId = table.Column<int>(type: "int", nullable: false),
+                    BusinessDate = table.Column<DateOnly>(type: "date", nullable: false),
+                    DepositDate = table.Column<DateOnly>(type: "date", nullable: false),
+                    Amount = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    FromGlCashAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    FromCashAccountCode = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    FromCashAccountName = table.Column<string>(type: "varchar(200)", maxLength: 200, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    ToGlBankAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    ToBankAccountCode = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    ToBankAccountName = table.Column<string>(type: "varchar(200)", maxLength: 200, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    ToBankName = table.Column<string>(type: "varchar(150)", maxLength: 150, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    ToAccountNumber = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    DepositSlipNo = table.Column<string>(type: "varchar(50)", maxLength: 50, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    DepositedBy = table.Column<string>(type: "varchar(150)", maxLength: 150, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    Remarks = table.Column<string>(type: "varchar(500)", maxLength: 500, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    Status = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, defaultValue: "Posted", collation: "utf8mb4_unicode_ci"),
+                    GlJournalNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    GlPostedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    GlReversalJournalNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    CancelReason = table.Column<string>(type: "varchar(250)", maxLength: 250, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    CancelledBy = table.Column<int>(type: "int", nullable: true),
+                    CancelledAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    CreatedBy = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_bank_deposits", x => x.BankDepositId);
+                    table.CheckConstraint("ck_bank_deposits_amount", "`Amount` > 0");
+                    table.ForeignKey(
+                        name: "FK_bank_deposits_hr_branches_BranchId",
+                        column: x => x.BranchId,
+                        principalTable: "hr_branches",
+                        principalColumn: "BranchId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_bank_deposits_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.InsertData(
+                table: "sub_nav_items",
+                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
+                values: new object[] { 47, "accounts.bank-deposits", "/dashboard/accounts/bank-deposits", null, "Bank Deposits", 12, 6 });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[] { 57, "NAV:accounts.bank-deposits", null, 47 });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_bank_deposits_BranchId_BusinessDate_Status",
+                table: "bank_deposits",
+                columns: new[] { "BranchId", "BusinessDate", "Status" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_bank_deposits_CreatedBy",
+                table: "bank_deposits",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_bank_deposits_DocNo",
+                table: "bank_deposits",
+                column: "DocNo",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_bank_deposits_ToGlBankAccountId",
+                table: "bank_deposits",
+                column: "ToGlBankAccountId");
+
+            // Grant the new Accounts sub-item (57) to Admin and to every role that already reaches
+            // Accounts (NAV:accounts 32, bank-accounts 26, cheque-books 33, received-cheques 34,
+            // expenses 54). Actions 31 = all, so Create (record) and Delete (cancel) included; admins
+            // can narrow it per role afterwards. Same idempotent pattern as GrantExpensePermissions.
+            migrationBuilder.Sql("""
+                INSERT IGNORE INTO `role_permissions` (`RoleId`, `PermissionId`, `Actions`)
+                SELECT r.`RoleId`, 57, 31
+                FROM `roles` r
+                WHERE LOWER(r.`Code`) = 'admin'
+                   OR EXISTS (SELECT 1 FROM `role_permissions` rp
+                              WHERE rp.`RoleId` = r.`RoleId` AND rp.`PermissionId` IN (26, 32, 33, 34, 54));
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("DELETE FROM `role_permissions` WHERE `PermissionId` = 57;");
+
+            migrationBuilder.DropTable(
+                name: "bank_deposits");
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 57);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 47);
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261009053644_EnableLowStockAlerts.Designer.cs b/Backend/ERPCore/Migrations/20261009053644_EnableLowStockAlerts.Designer.cs
new file mode 100644
index 0000000..6a3e9a4
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261009053644_EnableLowStockAlerts.Designer.cs
@@ -0,0 +1,10354 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261009053644_EnableLowStockAlerts")]
+    partial class EnableLowStockAlerts
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.Property<int>("BankDepositId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BankDepositId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("CancelledBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("DepositDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("DepositSlipNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("DepositedBy")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FromCashAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("FromCashAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<long>("FromGlCashAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("Remarks")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Posted");
+
+                    b.Property<string>("ToAccountNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("ToBankAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ToBankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ToBankName")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<long>("ToGlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("BankDepositId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ToGlBankAccountId");
+
+                    b.HasIndex("BranchId", "BusinessDate", "Status");
+
+                    b.ToTable("bank_deposits", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_bank_deposits_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        },
+                        new
+                        {
+                            PermissionId = 56,
+                            Code = "NAV:sales.day-end-report",
+                            SubNavItemId = 46
+                        },
+                        new
+                        {
+                            PermissionId = 57,
+                            Code = "NAV:accounts.bank-deposits",
+                            SubNavItemId = 47
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Cash");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Approved Invoices",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 46,
+                            Code = "sales.day-end-report",
+                            Href = "/dashboard/sales/day-end-report",
+                            Label = "Day-End Report",
+                            NavItemId = 13,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 47,
+                            Code = "accounts.bank-deposits",
+                            Href = "/dashboard/accounts/bank-deposits",
+                            Label = "Bank Deposits",
+                            NavItemId = 12,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261009053644_EnableLowStockAlerts.cs b/Backend/ERPCore/Migrations/20261009053644_EnableLowStockAlerts.cs
new file mode 100644
index 0000000..46e4e58
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261009053644_EnableLowStockAlerts.cs
@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <summary>
+    /// Data-only: turns the new "stock.low" (Low Stock / Reorder Alert) module on for the in-app
+    /// bell. A module with no row is silently off, so without this no alert would ever reach anyone
+    /// until an admin ticked it under Settings → Notifications. Only inserts when the notification
+    /// config exists and the module has no row yet, so a choice already made is left alone.
+    /// </summary>
+    public partial class EnableLowStockAlerts : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                INSERT INTO `notification_config_modules` (`NotificationConfigId`, `ModuleKey`, `EmailEnabled`, `SmsEnabled`, `InAppEnabled`)
+                SELECT c.`NotificationConfigId`, 'stock.low', 0, 0, 1
+                FROM `notification_config` c
+                WHERE c.`NotificationConfigId` = 1
+                  AND NOT EXISTS (SELECT 1 FROM `notification_config_modules` m WHERE m.`ModuleKey` = 'stock.low');
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("DELETE FROM `notification_config_modules` WHERE `ModuleKey` = 'stock.low';");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261009070055_AddDualApproval.Designer.cs b/Backend/ERPCore/Migrations/20261009070055_AddDualApproval.Designer.cs
new file mode 100644
index 0000000..9e52d83
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261009070055_AddDualApproval.Designer.cs
@@ -0,0 +1,10770 @@
+// <auto-generated />
+using System;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20261009070055_AddDualApproval")]
+    partial class AddDualApproval
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .UseCollation("utf8mb4_unicode_ci")
+                .HasAnnotation("ProductVersion", "9.0.20")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ApprovalConfig", b =>
+                {
+                    b.Property<int>("ApprovalConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Level2RoleCodes")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<decimal>("PriceAdjustmentLevel2ThresholdPercent")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("PriceAdjustmentLevels")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("StockAdjustmentLevel2ThresholdValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StockAdjustmentLevels")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ApprovalConfigId");
+
+                    b.ToTable("approval_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_approval_config_singleton", "`ApprovalConfigId` = 1");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            ApprovalConfigId = 1,
+                            PriceAdjustmentLevel2ThresholdPercent = 0m,
+                            PriceAdjustmentLevels = 2,
+                            RowVersion = 1u,
+                            StockAdjustmentLevel2ThresholdValue = 0m,
+                            StockAdjustmentLevels = 2
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.Property<int>("AttendanceRecordId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceRecordId"));
+
+                    b.Property<DateTime>("AttendanceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AttendanceStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("AttendanceUploadBatchId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("CheckIn")
+                        .HasColumnType("time(6)");
+
+                    b.Property<TimeSpan?>("CheckOut")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("DuplicateOfAttendanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EarlyLeaveMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("EditedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EditedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsManualOverride")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("LateMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<int>("OvertimeMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RowValidationStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceRecordId");
+
+                    b.HasIndex("AttendanceUploadBatchId");
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.HasIndex("EmployeeId", "AttendanceDate");
+
+                    b.ToTable("hr_attendance_records", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceUploadBatch", b =>
+                {
+                    b.Property<int>("AttendanceUploadBatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AttendanceUploadBatchId"));
+
+                    b.Property<DateTime?>("ConfirmedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ConfirmedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("OriginalFileName")
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("PeriodEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("PeriodStart")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RowCountDuplicate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountError")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RowCountTotal")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SourceType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("AttendanceUploadBatchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("hr_attendance_upload_batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<int>("AuditId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AuditId"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("ChangeSet")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AuditId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("EntityType", "EntityId");
+
+                    b.ToTable("audit_logs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.Property<int>("BankDepositId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BankDepositId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("CancelledBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("DepositDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("DepositSlipNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("DepositedBy")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FromCashAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("FromCashAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<long>("FromGlCashAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("Remarks")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Posted");
+
+                    b.Property<string>("ToAccountNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("ToBankAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ToBankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ToBankName")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<long>("ToGlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("BankDepositId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ToGlBankAccountId");
+
+                    b.HasIndex("BranchId", "BusinessDate", "Status");
+
+                    b.ToTable("bank_deposits", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_bank_deposits_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.Property<int>("BatchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BatchId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("BatchNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateOnly?>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BatchId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "BatchNo")
+                        .IsUnique();
+
+                    b.ToTable("batches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.Property<int>("BinId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BinId"));
+
+                    b.Property<string>("BinType")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BinId");
+
+                    b.HasIndex("WarehouseId", "Code")
+                        .IsUnique();
+
+                    b.ToTable("bins", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Branch", b =>
+                {
+                    b.Property<int>("BranchId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BranchId"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_branches", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BranchingEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarehouseBranchingEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("branch_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_branch_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Brand", b =>
+                {
+                    b.Property<int>("BrandId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BrandId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BrandId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("brands", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Property<int>("BundleSaleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleId"));
+
+                    b.Property<string>("BundleCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("BundleDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("BundleName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BundleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("BundlePrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ComponentSubtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("MarginAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleId");
+
+                    b.HasIndex("BundleNo")
+                        .IsUnique();
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sales", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.Property<int>("BundleSaleLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleLineId"));
+
+                    b.Property<int>("BundleSaleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsComponent")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleLineId");
+
+                    b.HasIndex("BundleSaleId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TemplateCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("BundleSaleTemplateId");
+
+                    b.HasIndex("TemplateCode")
+                        .IsUnique();
+
+                    b.ToTable("bundle_sale_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.Property<int>("BundleSaleTemplateLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BundleSaleTemplateLineId"));
+
+                    b.Property<int>("BundleSaleTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IncludeInBundle")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("BundleSaleTemplateLineId");
+
+                    b.HasIndex("BundleSaleTemplateId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("bundle_sale_template_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("categories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.Property<int>("CustomerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CustomerId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreditDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CreditLimit")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CustomerCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CustomerType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxRegistrationNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("CustomerId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CustomerCode")
+                        .IsUnique();
+
+                    b.HasIndex("CustomerType");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("customers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.Property<int>("DepartmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DepartmentId"));
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("HeadEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("ParentDepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DepartmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("HeadEmployeeId");
+
+                    b.HasIndex("ParentDepartmentId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_departments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Designation", b =>
+                {
+                    b.Property<int>("DesignationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DesignationId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("DesignationId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_designations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.DocumentApproval", b =>
+                {
+                    b.Property<int>("DocumentApprovalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DocumentApprovalId"));
+
+                    b.Property<string>("Comment")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("DecidedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DecidedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Decision")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("DocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("int");
+
+                    b.HasKey("DocumentApprovalId");
+
+                    b.HasIndex("DecidedBy");
+
+                    b.HasIndex("DocType", "DocId");
+
+                    b.ToTable("document_approvals", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.Property<int>("EmployeeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeId"));
+
+                    b.Property<string>("AddressLine1")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime?>("ConfirmationDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Country")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DesignationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EmergencyContactRelationship")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("EmployeeCode")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmploymentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EpfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("EtfNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Gender")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("HireDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("LastWorkingDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Nationality")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Nic")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PersonalMobile")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("PostalCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ProfilePhotoPath")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ReportingManagerId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxIdentificationNumber")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkShiftId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("DesignationId");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("EmployeeCode")
+                        .IsUnique();
+
+                    b.HasIndex("EmploymentTypeId");
+
+                    b.HasIndex("ReportingManagerId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("WorkShiftId");
+
+                    b.ToTable("hr_employees", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.Property<int>("EmployeeBankDetailId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeBankDetailId"));
+
+                    b.Property<string>("AccountHolderName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("BankName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("SwiftCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmployeeBankDetailId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("hr_employee_bank_details", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.Property<int>("EmployeeDocumentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeDocumentId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExpiryDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("HrDocumentTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("IssueDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VerifiedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeDocumentId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("ExpiryDate");
+
+                    b.HasIndex("HrDocumentTypeId");
+
+                    b.ToTable("hr_employee_documents", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Property<int>("EmployeeLoanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeLoanId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("InstallmentAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("InterestRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<string>("LoanKind")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("NumberOfInstallments")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OutstandingBalance")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("PrincipalAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StartMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeLoanId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employee_loans", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureId"));
+
+                    b.Property<DateTime>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("EmployeeSalaryStructureId");
+
+                    b.HasIndex("EmployeeId", "EffectiveTo");
+
+                    b.ToTable("hr_employee_salary_structures", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.Property<int>("EmployeeSalaryStructureLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmployeeSalaryStructureLineId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeSalaryStructureId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EmployeeSalaryStructureLineId");
+
+                    b.HasIndex("EmployeeSalaryStructureId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_employee_salary_structure_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmploymentType", b =>
+                {
+                    b.Property<int>("EmploymentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EmploymentTypeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("EmploymentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_employment_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Property<int>("GrnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("grns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowVat")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("grn_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_grn_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Property<int>("GrnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HoldStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("PoLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PoUnitPrice")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReceivedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("VatAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.HasKey("GrnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoLineId");
+
+                    b.ToTable("grn_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.Property<int>("GrnLineWarrantyNumberId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineWarrantyNumberId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WarrantyNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("GrnLineWarrantyNumberId");
+
+                    b.HasIndex("GrnLineId", "WarrantyNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_warranty_numbers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.HrDocumentType", b =>
+                {
+                    b.Property<int>("HrDocumentTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("HrDocumentTypeId"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("ExpiryTracked")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiredAtOnboarding")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("HrDocumentTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_document_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Property<int>("ItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("BaseUomId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BrandId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("ContentBaseQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentBaseUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal?>("ContentQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("ContentUnit")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DefaultVendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("SellingFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("SellingMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Sku")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("StockNature")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("SubCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TaxRateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TrackingMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Warranty")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("NonWarranty");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BaseUomId");
+
+                    b.HasIndex("BrandId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DefaultVendorId");
+
+                    b.HasIndex("Sku")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubCategoryId");
+
+                    b.HasIndex("TaxRateId");
+
+                    b.ToTable("items", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.Property<int>("ItemImageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemImageId"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<string>("RelativePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(260)
+                        .HasColumnType("varchar(260)");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UploadedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemImageId");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("item_images", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemPriceHistory", b =>
+                {
+                    b.Property<int>("ItemPriceHistoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemPriceHistoryId"));
+
+                    b.Property<DateTime>("AppliedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel1By")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApprovedLevel2By")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NewFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("PriceAdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemPriceHistoryId");
+
+                    b.HasIndex("PriceAdjustmentId");
+
+                    b.HasIndex("ItemId", "AppliedAt");
+
+                    b.ToTable("item_price_history", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.Property<int>("ReorderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReorderId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ReorderPoint")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReorderQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReorderId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId")
+                        .IsUnique();
+
+                    b.ToTable("item_reorders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemType", b =>
+                {
+                    b.Property<int>("ItemTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemTypeId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsMeasurable")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ItemTypeId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("item_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.JournalEntryStub", b =>
+                {
+                    b.Property<int>("JournalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("JournalId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("CreditAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("DebitAccount")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.HasKey("JournalId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("journal_entry_stubs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.Property<int>("LeaveBalanceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveBalanceId"));
+
+                    b.Property<decimal>("AdjustmentDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<decimal>("CarriedForwardDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EntitledDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TakenDays")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("LeaveBalanceId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("EmployeeId", "LeaveTypeId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("hr_leave_balances", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.Property<int>("LeaveRequestId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveRequestId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DaysCount")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LeaveTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LeaveRequestId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LeaveTypeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("StartDate", "EndDate");
+
+                    b.ToTable("hr_leave_requests", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveType", b =>
+                {
+                    b.Property<int>("LeaveTypeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LeaveTypeId"));
+
+                    b.Property<decimal>("AccrualPerYear")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<bool>("CarryForwardAllowed")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("CountsAsNoPay")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsPaid")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("MaxCarryForwardDays")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<bool>("RequiresApproval")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("LeaveTypeId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_leave_types", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.Property<int>("LoanInstallmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoanInstallmentId"));
+
+                    b.Property<int>("DueMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DueYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeLoanId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InstallmentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("PaidAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScheduledAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("LoanInstallmentId");
+
+                    b.HasIndex("EmployeeLoanId");
+
+                    b.HasIndex("PayrollRunId");
+
+                    b.HasIndex("DueYear", "DueMonth");
+
+                    b.ToTable("hr_loan_installments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.Property<int>("LoginActivityId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LoginActivityId"));
+
+                    b.Property<string>("DeviceLabel")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<DateTime>("LoginAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("UserAgent")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LoginActivityId");
+
+                    b.HasIndex("UserId", "LoginAt");
+
+                    b.ToTable("login_activities", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Property<int>("NavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("NavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            NavItemId = 1,
+                            Code = "dashboard",
+                            Href = "/dashboard",
+                            Label = "Dashboard",
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 2,
+                            Code = "products",
+                            Href = "/dashboard/products",
+                            Label = "Products",
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 4,
+                            Code = "procurement",
+                            Href = "/dashboard/procurement",
+                            Label = "Procurement",
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 5,
+                            Code = "receiving",
+                            Href = "/dashboard/receiving/grn",
+                            Label = "Receiving",
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 6,
+                            Code = "stock",
+                            Href = "/dashboard/stock",
+                            Label = "Stock",
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 7,
+                            Code = "warehouses",
+                            Href = "/dashboard/warehouse",
+                            Label = "Warehouses",
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 8,
+                            Code = "orders",
+                            Href = "/dashboard/orders",
+                            Label = "Orders",
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 9,
+                            Code = "settings",
+                            Href = "/dashboard/settings",
+                            Label = "Settings",
+                            SortOrder = 9,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 10,
+                            Code = "help",
+                            Href = "/dashboard/help",
+                            Label = "Help",
+                            SortOrder = 10,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 11,
+                            Code = "ledgers",
+                            Href = "/dashboard/ledgers",
+                            Label = "Ledgers",
+                            SortOrder = 11,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 12,
+                            Code = "accounts",
+                            Href = "/dashboard/accounts",
+                            Label = "Accounts",
+                            SortOrder = 12,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 13,
+                            Code = "sales",
+                            Href = "/dashboard/sales",
+                            Label = "Sales",
+                            SortOrder = 13,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            NavItemId = 14,
+                            Code = "production",
+                            Href = "/dashboard/production",
+                            Label = "Production",
+                            SortOrder = 14,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Property<int>("NotificationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("RelatedEntityId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RelatedEntityType")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("notifications", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("notification_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_notification_config_singleton", "`NotificationConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.Property<int>("NotificationConfigModuleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationConfigModuleId"));
+
+                    b.Property<bool>("EmailEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("InAppEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("ModuleKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NotificationConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("SmsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("NotificationConfigModuleId");
+
+                    b.HasIndex("ModuleKey")
+                        .IsUnique();
+
+                    b.HasIndex("NotificationConfigId");
+
+                    b.ToTable("notification_config_modules", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.Property<int>("NotificationRecipientId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("NotificationRecipientId"));
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("NotificationId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReadAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("NotificationRecipientId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.HasIndex("UserId", "IsRead", "NotificationId");
+
+                    b.ToTable("notification_recipients", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("SequenceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SequenceId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int")
+                        .HasColumnName("branch_id");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)")
+                        .HasColumnName("doc_type");
+
+                    b.Property<int>("LastNumber")
+                        .HasColumnType("int")
+                        .HasColumnName("last_number");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int")
+                        .HasColumnName("year");
+
+                    b.HasKey("SequenceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocType", "BranchId", "Year")
+                        .IsUnique();
+
+                    b.ToTable("number_sequences", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Property<int>("PayrollLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineId"));
+
+                    b.Property<int>("AbsentDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("BasicSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("EpfEmployeeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EpfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("EtfEmployerAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("GrossSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("LateDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("LateMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeaveDays")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LoanDeductionAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NetSalary")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("NoPayAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("OtMinutesTotal")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("OtherDeductionsAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OvertimeAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("PayrollRunId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PresentDays")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalAllowances")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WorkingDays")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("PayrollRunId", "EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payroll_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.Property<int>("PayrollLineComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollLineComponentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("ComponentCategory")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalaryComponentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollLineComponentId");
+
+                    b.HasIndex("PayrollLineId");
+
+                    b.HasIndex("SalaryComponentId");
+
+                    b.ToTable("hr_payroll_line_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Property<int>("PayrollRunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollRunId"));
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GeneratedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("LockedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodYear")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("UnlockReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<DateTime?>("UnlockedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UnlockedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayrollRunId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("PeriodYear", "PeriodMonth", "BranchId");
+
+                    b.ToTable("hr_payroll_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollStatutorySetting", b =>
+                {
+                    b.Property<int>("PayrollStatutorySettingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayrollStatutorySettingId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("EpfEmployeeRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EpfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("EtfEmployerRate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<decimal>("OtMultiplierDefault")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.HasKey("PayrollStatutorySettingId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_payroll_statutory_settings", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.Property<int>("PayslipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PayslipId"));
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PayrollLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReleasedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ReleasedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("PayslipId");
+
+                    b.HasIndex("PayrollLineId")
+                        .IsUnique();
+
+                    b.ToTable("hr_payslips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.Property<int>("PermissionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PermissionId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("varchar(80)");
+
+                    b.Property<int?>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SubNavItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PermissionId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.HasIndex("SubNavItemId");
+
+                    b.ToTable("permissions", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            PermissionId = 1,
+                            Code = "NAV:dashboard",
+                            NavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 2,
+                            Code = "NAV:products",
+                            NavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 3,
+                            Code = "NAV:procurement.vendors",
+                            SubNavItemId = 30
+                        },
+                        new
+                        {
+                            PermissionId = 4,
+                            Code = "NAV:procurement",
+                            NavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 5,
+                            Code = "NAV:receiving",
+                            NavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 6,
+                            Code = "NAV:stock",
+                            NavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 7,
+                            Code = "NAV:warehouses",
+                            NavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 8,
+                            Code = "NAV:orders",
+                            NavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 9,
+                            Code = "NAV:settings",
+                            NavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 10,
+                            Code = "NAV:help",
+                            NavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 11,
+                            Code = "NAV:products.item",
+                            SubNavItemId = 1
+                        },
+                        new
+                        {
+                            PermissionId = 12,
+                            Code = "NAV:products.category",
+                            SubNavItemId = 2
+                        },
+                        new
+                        {
+                            PermissionId = 13,
+                            Code = "NAV:products.brand",
+                            SubNavItemId = 3
+                        },
+                        new
+                        {
+                            PermissionId = 14,
+                            Code = "NAV:products.item-type",
+                            SubNavItemId = 4
+                        },
+                        new
+                        {
+                            PermissionId = 15,
+                            Code = "NAV:products.uom",
+                            SubNavItemId = 5
+                        },
+                        new
+                        {
+                            PermissionId = 16,
+                            Code = "NAV:products.configuration",
+                            SubNavItemId = 6
+                        },
+                        new
+                        {
+                            PermissionId = 17,
+                            Code = "NAV:settings.roles",
+                            SubNavItemId = 7
+                        },
+                        new
+                        {
+                            PermissionId = 18,
+                            Code = "NAV:settings.users",
+                            SubNavItemId = 8
+                        },
+                        new
+                        {
+                            PermissionId = 28,
+                            Code = "NAV:procurement.requisitions",
+                            SubNavItemId = 17
+                        },
+                        new
+                        {
+                            PermissionId = 29,
+                            Code = "NAV:procurement.rfqs",
+                            SubNavItemId = 18
+                        },
+                        new
+                        {
+                            PermissionId = 30,
+                            Code = "NAV:procurement.purchase-orders",
+                            SubNavItemId = 19
+                        },
+                        new
+                        {
+                            PermissionId = 31,
+                            Code = "NAV:procurement.purchase-returns",
+                            SubNavItemId = 20
+                        },
+                        new
+                        {
+                            PermissionId = 19,
+                            Code = "NAV:ledgers",
+                            NavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 20,
+                            Code = "NAV:ledgers.trial-balance",
+                            SubNavItemId = 9
+                        },
+                        new
+                        {
+                            PermissionId = 21,
+                            Code = "NAV:ledgers.balance-sheet",
+                            SubNavItemId = 10
+                        },
+                        new
+                        {
+                            PermissionId = 22,
+                            Code = "NAV:ledgers.general-ledger",
+                            SubNavItemId = 11
+                        },
+                        new
+                        {
+                            PermissionId = 23,
+                            Code = "NAV:ledgers.profit-and-loss",
+                            SubNavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 24,
+                            Code = "NAV:ledgers.cash-flow",
+                            SubNavItemId = 13
+                        },
+                        new
+                        {
+                            PermissionId = 25,
+                            Code = "NAV:ledgers.budget-vs-actual",
+                            SubNavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 27,
+                            Code = "NAV:ledgers.tax-report",
+                            SubNavItemId = 16
+                        },
+                        new
+                        {
+                            PermissionId = 26,
+                            Code = "NAV:accounts.bank-accounts",
+                            SubNavItemId = 15
+                        },
+                        new
+                        {
+                            PermissionId = 32,
+                            Code = "NAV:accounts",
+                            NavItemId = 12
+                        },
+                        new
+                        {
+                            PermissionId = 33,
+                            Code = "NAV:accounts.cheque-books",
+                            SubNavItemId = 21
+                        },
+                        new
+                        {
+                            PermissionId = 34,
+                            Code = "NAV:accounts.received-cheques",
+                            SubNavItemId = 22
+                        },
+                        new
+                        {
+                            PermissionId = 35,
+                            Code = "NAV:production",
+                            NavItemId = 14
+                        },
+                        new
+                        {
+                            PermissionId = 36,
+                            Code = "NAV:production.templates",
+                            SubNavItemId = 27
+                        },
+                        new
+                        {
+                            PermissionId = 37,
+                            Code = "NAV:production.runs",
+                            SubNavItemId = 25
+                        },
+                        new
+                        {
+                            PermissionId = 38,
+                            Code = "NAV:production.produced",
+                            SubNavItemId = 26
+                        },
+                        new
+                        {
+                            PermissionId = 39,
+                            Code = "NAV:procurement.purchase-invoices",
+                            SubNavItemId = 28
+                        },
+                        new
+                        {
+                            PermissionId = 40,
+                            Code = "NAV:settings.branches",
+                            SubNavItemId = 29
+                        },
+                        new
+                        {
+                            PermissionId = 41,
+                            Code = "NAV:stock.ledger",
+                            SubNavItemId = 31
+                        },
+                        new
+                        {
+                            PermissionId = 42,
+                            Code = "NAV:stock.enquiry",
+                            SubNavItemId = 32
+                        },
+                        new
+                        {
+                            PermissionId = 43,
+                            Code = "NAV:stock.valuation",
+                            SubNavItemId = 33
+                        },
+                        new
+                        {
+                            PermissionId = 44,
+                            Code = "NAV:stock.transfers",
+                            SubNavItemId = 34
+                        },
+                        new
+                        {
+                            PermissionId = 45,
+                            Code = "NAV:stock.adjustments",
+                            SubNavItemId = 35
+                        },
+                        new
+                        {
+                            PermissionId = 46,
+                            Code = "NAV:stock.counts",
+                            SubNavItemId = 36
+                        },
+                        new
+                        {
+                            PermissionId = 47,
+                            Code = "NAV:stock.reorder-alerts",
+                            SubNavItemId = 37
+                        },
+                        new
+                        {
+                            PermissionId = 48,
+                            Code = "NAV:stock.wastage",
+                            SubNavItemId = 38
+                        },
+                        new
+                        {
+                            PermissionId = 49,
+                            Code = "NAV:sales.bundle-templates",
+                            SubNavItemId = 23
+                        },
+                        new
+                        {
+                            PermissionId = 50,
+                            Code = "NAV:sales.invoices",
+                            SubNavItemId = 40
+                        },
+                        new
+                        {
+                            PermissionId = 51,
+                            Code = "NAV:sales.free-issues",
+                            SubNavItemId = 41
+                        },
+                        new
+                        {
+                            PermissionId = 52,
+                            Code = "NAV:sales.day-end",
+                            SubNavItemId = 42
+                        },
+                        new
+                        {
+                            PermissionId = 53,
+                            Code = "NAV:products.tax-rates",
+                            SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        },
+                        new
+                        {
+                            PermissionId = 56,
+                            Code = "NAV:sales.day-end-report",
+                            SubNavItemId = 46
+                        },
+                        new
+                        {
+                            PermissionId = 57,
+                            Code = "NAV:accounts.bank-deposits",
+                            SubNavItemId = 47
+                        },
+                        new
+                        {
+                            PermissionId = 58,
+                            Code = "NAV:products.price-adjustments",
+                            SubNavItemId = 48
+                        },
+                        new
+                        {
+                            PermissionId = 59,
+                            Code = "NAV:settings.approvals",
+                            SubNavItemId = 49
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.Property<int>("PoLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PoId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("Tax")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PoId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("po_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustment", b =>
+                {
+                    b.Property<int>("PriceAdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PriceAdjustmentId"));
+
+                    b.Property<DateTime?>("AppliedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ApprovedLevel1At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel1By")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ApprovedLevel2At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel2By")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("RejectReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("RejectedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("RejectedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RequiredApprovals")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)")
+                        .HasDefaultValue("PendingApproval");
+
+                    b.HasKey("PriceAdjustmentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("price_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustmentLine", b =>
+                {
+                    b.Property<int>("PriceAdjustmentLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PriceAdjustmentLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NewFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PriceAdjustmentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PriceAdjustmentLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PriceAdjustmentId");
+
+                    b.ToTable("price_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("BatchListsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("BrandsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("CustomVariantsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("CustomWarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemImagesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("ItemTypesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<bool>("SellingPricesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SerialNumbersEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("SubcategoriesEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("WarrantyPeriodsEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("product_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_product_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Property<int>("RunId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunId"));
+
+                    b.Property<int?>("CancelReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("OutputBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ReworkCount")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("ScaleFactor")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("TargetQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunId");
+
+                    b.HasIndex("CancelReasonCodeId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputBinId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("TemplateId", "Status");
+
+                    b.ToTable("production_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Property<int>("TemplateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TemplateId"));
+
+                    b.Property<string>("Annotations")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("production_templates", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("VendorInvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("VendorInvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("VendorSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("VendorSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("PurchaseInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("VendorId", "VendorInvoiceNo");
+
+                    b.ToTable("purchase_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.Property<int>("PurchaseInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoiceLineId"));
+
+                    b.Property<int>("GrnId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("VatTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("PurchaseInvoiceLineId");
+
+                    b.HasIndex("GrnId")
+                        .IsUnique();
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.Property<int>("PurchaseInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PurchaseInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("PurchaseInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("PurchaseInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("PurchaseInvoiceId");
+
+                    b.ToTable("purchase_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Property<int>("PoId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PoId"));
+
+                    b.Property<bool>("ApprovalRequired")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("ApprovedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApproverUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int?>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PoId");
+
+                    b.HasIndex("ApproverUserId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("purchase_orders", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("purchase_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.ToTable("purchase_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ReasonCode", b =>
+                {
+                    b.Property<int>("ReasonCodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReasonCodeId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Context")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("ReasonCodeId");
+
+                    b.HasIndex("Context", "Code")
+                        .IsUnique();
+
+                    b.ToTable("reason_codes", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Property<int>("RequisitionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RequisitionId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RequisitionId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("requisitions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.Property<int>("ReqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RequiredBy")
+                        .HasColumnType("date");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("requisition_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Property<int>("RfqId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("RequisitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RfqId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequisitionId");
+
+                    b.ToTable("rfqs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.Property<int>("RfqLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RfqLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RfqLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RfqId");
+
+                    b.ToTable("rfq_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Role", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RoleId"));
+
+                    b.Property<Guid>("AuthRoleId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_role_id");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystemRole")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("RoleId");
+
+                    b.HasIndex("AuthRoleId")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("roles", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PermissionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Actions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(31);
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("role_permissions", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.Property<int>("RunEdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunEdgeId"));
+
+                    b.Property<int>("ChildRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentRunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunEdgeId");
+
+                    b.HasIndex("ChildRunStageId");
+
+                    b.HasIndex("RunId");
+
+                    b.HasIndex("ParentRunStageId", "ChildRunStageId")
+                        .IsUnique();
+
+                    b.ToTable("run_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Property<int>("RunStageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunStageId"));
+
+                    b.Property<DateTime?>("ActualEndAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ActualStartAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FieldValues")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int?>("TemplateStageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunStageId");
+
+                    b.HasIndex("TemplateStageId");
+
+                    b.HasIndex("RunId", "Status");
+
+                    b.ToTable("run_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.Property<int>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EventId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("RunId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EventId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("RunId", "EventId");
+
+                    b.ToTable("run_stage_events", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.Property<int>("RunInputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunInputId"));
+
+                    b.Property<decimal>("ConsumedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ConsumedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DeliveredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("FromRunOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<decimal>("ReturnedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ReturnedValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("RunInputId");
+
+                    b.HasIndex("FromRunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.ToTable("run_stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.Property<int>("RunOutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("RunOutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PlannedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("ProducedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("RunStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ScrapReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("ScrappedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TransferredQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("RunOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("RunStageId");
+
+                    b.HasIndex("ScrapReasonCodeId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("run_stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalaryComponent", b =>
+                {
+                    b.Property<int>("SalaryComponentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalaryComponentId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ComponentType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsEpfEtfApplicable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsTaxable")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SalaryComponentId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_salary_components", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.Property<int>("ConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowCashCustomer")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowDiscounts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowFreeItems")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("AllowOverStockSale")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("AllowWarehouseSelection")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int?>("CashCustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DefaultWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ConfigId");
+
+                    b.HasIndex("CashCustomerId");
+
+                    b.HasIndex("DefaultWarehouseId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("sales_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_sales_config_singleton", "`ConfigId` = 1");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Property<int>("SalesDayEndId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesDayEndId"));
+
+                    b.Property<decimal>("BalanceTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BundleCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ClosedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ClosedBy")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("CostOfGoodsSold")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SlipCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("SalesDayEndId");
+
+                    b.HasIndex("ClosedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("CashierUserId", "BusinessDate")
+                        .IsUnique();
+
+                    b.ToTable("sales_day_ends", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Property<int>("SalesInvoiceId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CreatorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CustomerSnapshotTaxNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("InvoiceDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("InvoiceNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InvoiceType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("B2C");
+
+                    b.Property<decimal>("NetPayable")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RoundOff")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatorUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("InvoiceDate");
+
+                    b.HasIndex("InvoiceNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoices", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_invoice_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.Property<int>("SalesInvoicePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoicePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Cash");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("SalesInvoiceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoicePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("SalesInvoiceId");
+
+                    b.ToTable("sales_invoice_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Property<int>("ReturnId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_returns", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Property<int>("ReturnLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ReturnId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ReturnLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ReturnId");
+
+                    b.HasIndex("SalesInvoiceLineId");
+
+                    b.ToTable("sales_return_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Property<int>("SalesSlipId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipId"));
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("CashierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomerSnapshotName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int?>("DayEndId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("GrandTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<DateTime>("SlipDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SlipNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<decimal>("Subtotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipId");
+
+                    b.HasIndex("CashierUserId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("DayEndId");
+
+                    b.HasIndex("SlipDate");
+
+                    b.HasIndex("SlipNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slips", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Property<int>("SalesSlipLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineId"));
+
+                    b.Property<decimal>("BaseCost")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("DiscountAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("DiscountMode")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DiscountPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("FreeQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<bool>("IsFreeIssue")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("LineTotal")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("NetUnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("ParentLineId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PriceSource")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SalesSlipId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TaxAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("TaxPct")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SalesSlipId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("sales_slip_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.Property<int>("SerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialId"));
+
+                    b.Property<string>("Barcode")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialId");
+
+                    b.HasIndex("Barcode")
+                        .IsUnique();
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("ItemId", "SerialNo")
+                        .IsUnique();
+
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
+                    b.ToTable("serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.Property<int>("EdgeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("EdgeId"));
+
+                    b.Property<int>("ChildStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ParentStageId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("EdgeId");
+
+                    b.HasIndex("ChildStageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("ParentStageId", "ChildStageId")
+                        .IsUnique();
+
+                    b.ToTable("stage_edges", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.Property<int>("InputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("InputId"));
+
+                    b.Property<int?>("FromOutputId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("QtyUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.HasKey("InputId");
+
+                    b.HasIndex("FromOutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.ToTable("stage_inputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.Property<int>("OutputId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("OutputId"));
+
+                    b.Property<int?>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("QtyPerBatch")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StageId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UomId")
+                        .HasColumnType("int");
+
+                    b.HasKey("OutputId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("StageId");
+
+                    b.HasIndex("UomId");
+
+                    b.ToTable("stage_outputs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Property<int>("AdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
+
+                    b.Property<DateTime?>("ApprovedLevel1At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel1By")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ApprovedLevel2At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel2By")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ReasonCodeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RejectReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("RejectedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("RejectedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RequiredApprovals")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjustmentId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReasonCodeId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.Property<int>("AdjLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjLineId"));
+
+                    b.Property<int>("AdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyDelta")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RequestedSerialIds")
+                        .HasMaxLength(4000)
+                        .HasColumnType("varchar(4000)");
+
+                    b.Property<string>("RequestedSerialNos")
+                        .HasMaxLength(4000)
+                        .HasColumnType("varchar(4000)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AdjLineId");
+
+                    b.HasIndex("AdjustmentId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_adjustment_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Property<int>("CountId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CountType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("CountId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.ToTable("stock_counts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.Property<int>("CountLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("CountLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CountId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("CountedQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("SystemQty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("Variance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("CountLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("CountId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.ToTable("stock_count_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.Property<int>("LayerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LayerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyRemaining")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateTime>("ReceiptDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LayerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("GrnLineId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "ReceiptDate", "LayerId");
+
+                    b.ToTable("stock_layers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.Property<int>("LedgerId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("LedgerId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Direction")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("varchar(5)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QtyBase")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("RunningBalance")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("LedgerId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WarehouseId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("ItemId", "WarehouseId", "CreatedAt");
+
+                    b.HasIndex("ItemId", "WarehouseId", "LedgerId");
+
+                    b.ToTable("stock_ledger", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Property<int>("TransferId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DestWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SrcWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.HasKey("TransferId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DestWarehouseId");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("SrcWarehouseId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("stock_transfers", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Property<int>("TransferLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TransferLineId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DestBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReceived")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SrcBinId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("TransferLineId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("DestBinId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SrcBinId");
+
+                    b.HasIndex("TransferId");
+
+                    b.ToTable("stock_transfer_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.Property<int>("SubCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubCategoryId"));
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubCategoryId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("CategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("subcategories", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.Property<int>("SubNavItemId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SubNavItemId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Href")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int>("NavItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.HasKey("SubNavItemId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("NavItemId");
+
+                    b.ToTable("sub_nav_items", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            SubNavItemId = 1,
+                            Code = "products.item",
+                            Href = "/dashboard/products",
+                            Label = "Item",
+                            NavItemId = 2,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 2,
+                            Code = "products.category",
+                            Href = "/dashboard/products/categories",
+                            Label = "Category",
+                            NavItemId = 2,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 3,
+                            Code = "products.brand",
+                            Href = "/dashboard/products/brands",
+                            Label = "Brand",
+                            NavItemId = 2,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 4,
+                            Code = "products.item-type",
+                            Href = "/dashboard/products/item-types",
+                            Label = "Item Type",
+                            NavItemId = 2,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 5,
+                            Code = "products.uom",
+                            Href = "/dashboard/products/uoms",
+                            Label = "UOM",
+                            NavItemId = 2,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 6,
+                            Code = "products.configuration",
+                            Href = "/dashboard/products/settings",
+                            Label = "Configuration",
+                            NavItemId = 2,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 43,
+                            Code = "products.tax-rates",
+                            Href = "/dashboard/products/tax-rates",
+                            Label = "Tax Rates",
+                            NavItemId = 2,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 48,
+                            Code = "products.price-adjustments",
+                            Href = "/dashboard/products/price-adjustments",
+                            Label = "Price Adjustments",
+                            NavItemId = 2,
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 29,
+                            Code = "settings.branches",
+                            Href = "/dashboard/settings/branches",
+                            Label = "Branches",
+                            NavItemId = 9,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 7,
+                            Code = "settings.roles",
+                            Href = "/dashboard/settings/roles",
+                            Label = "Roles",
+                            NavItemId = 9,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 8,
+                            Code = "settings.users",
+                            Href = "/dashboard/settings/users",
+                            Label = "Users",
+                            NavItemId = 9,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 24,
+                            Code = "settings.notification-config",
+                            Href = "/dashboard/settings/notification-config",
+                            Label = "Notification Config",
+                            NavItemId = 9,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 49,
+                            Code = "settings.approvals",
+                            Href = "/dashboard/settings/approvals",
+                            Label = "Approvals",
+                            NavItemId = 9,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 40,
+                            Code = "sales.invoices",
+                            Href = "/dashboard/sales/invoices",
+                            Label = "Sales",
+                            NavItemId = 13,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 23,
+                            Code = "sales.bundle-templates",
+                            Href = "/dashboard/sales/bundles/templates",
+                            Label = "Bundle Templates",
+                            NavItemId = 13,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 41,
+                            Code = "sales.free-issues",
+                            Href = "/dashboard/sales/free-issues",
+                            Label = "Free Issues",
+                            NavItemId = 13,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 42,
+                            Code = "sales.day-end",
+                            Href = "/dashboard/sales/day-end",
+                            Label = "Approved Invoices",
+                            NavItemId = 13,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 46,
+                            Code = "sales.day-end-report",
+                            Href = "/dashboard/sales/day-end-report",
+                            Label = "Day-End Report",
+                            NavItemId = 13,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 30,
+                            Code = "procurement.vendors",
+                            Href = "/dashboard/vendors",
+                            Label = "Vendors",
+                            NavItemId = 4,
+                            SortOrder = 0,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 17,
+                            Code = "procurement.requisitions",
+                            Href = "/dashboard/procurement/requisitions",
+                            Label = "Requisitions",
+                            NavItemId = 4,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 18,
+                            Code = "procurement.rfqs",
+                            Href = "/dashboard/procurement/rfqs",
+                            Label = "RFQs",
+                            NavItemId = 4,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 19,
+                            Code = "procurement.purchase-orders",
+                            Href = "/dashboard/procurement/purchase-orders",
+                            Label = "Purchase Orders",
+                            NavItemId = 4,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 20,
+                            Code = "procurement.purchase-returns",
+                            Href = "/dashboard/procurement/purchase-returns",
+                            Label = "Purchase Returns",
+                            NavItemId = 4,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 28,
+                            Code = "procurement.purchase-invoices",
+                            Href = "/dashboard/procurement/purchase-invoices",
+                            Label = "Purchase Invoices",
+                            NavItemId = 4,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 9,
+                            Code = "ledgers.trial-balance",
+                            Href = "/dashboard/ledgers/trial-balance",
+                            Label = "Trial Balance",
+                            NavItemId = 11,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 10,
+                            Code = "ledgers.balance-sheet",
+                            Href = "/dashboard/ledgers/balance-sheet",
+                            Label = "Balance Sheet",
+                            NavItemId = 11,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 11,
+                            Code = "ledgers.general-ledger",
+                            Href = "/dashboard/ledgers/general-ledger",
+                            Label = "General Ledger",
+                            NavItemId = 11,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 12,
+                            Code = "ledgers.profit-and-loss",
+                            Href = "/dashboard/ledgers/profit-and-loss",
+                            Label = "Profit & Loss",
+                            NavItemId = 11,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 13,
+                            Code = "ledgers.cash-flow",
+                            Href = "/dashboard/ledgers/cash-flow",
+                            Label = "Cash Flow",
+                            NavItemId = 11,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 14,
+                            Code = "ledgers.budget-vs-actual",
+                            Href = "/dashboard/ledgers/budget-vs-actual",
+                            Label = "Budget vs Actual",
+                            NavItemId = 11,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 16,
+                            Code = "ledgers.tax-report",
+                            Href = "/dashboard/ledgers/tax-report",
+                            Label = "Tax Report",
+                            NavItemId = 11,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 15,
+                            Code = "accounts.bank-accounts",
+                            Href = "/dashboard/accounts/bank-accounts",
+                            Label = "Cash / Bank Accounts",
+                            NavItemId = 12,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 21,
+                            Code = "accounts.cheque-books",
+                            Href = "/dashboard/accounts/cheque-books",
+                            Label = "Cheque Books",
+                            NavItemId = 12,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 22,
+                            Code = "accounts.received-cheques",
+                            Href = "/dashboard/accounts/received-cheques",
+                            Label = "Received Cheques",
+                            NavItemId = 12,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 47,
+                            Code = "accounts.bank-deposits",
+                            Href = "/dashboard/accounts/bank-deposits",
+                            Label = "Bank Deposits",
+                            NavItemId = 12,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 27,
+                            Code = "production.templates",
+                            Href = "/dashboard/production/templates",
+                            Label = "Templates",
+                            NavItemId = 14,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 25,
+                            Code = "production.runs",
+                            Href = "/dashboard/production/runs",
+                            Label = "Runs",
+                            NavItemId = 14,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 26,
+                            Code = "production.produced",
+                            Href = "/dashboard/production/produced",
+                            Label = "Produced",
+                            NavItemId = 14,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 31,
+                            Code = "stock.ledger",
+                            Href = "/dashboard/stock/ledger",
+                            Label = "Stock Ledger",
+                            NavItemId = 6,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 32,
+                            Code = "stock.enquiry",
+                            Href = "/dashboard/stock/enquiry",
+                            Label = "Stock Enquiry",
+                            NavItemId = 6,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 33,
+                            Code = "stock.valuation",
+                            Href = "/dashboard/stock/valuation",
+                            Label = "Valuation",
+                            NavItemId = 6,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 34,
+                            Code = "stock.transfers",
+                            Href = "/dashboard/stock/transfers",
+                            Label = "Transfers",
+                            NavItemId = 6,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 35,
+                            Code = "stock.adjustments",
+                            Href = "/dashboard/stock/adjustments",
+                            Label = "Adjustments",
+                            NavItemId = 6,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 36,
+                            Code = "stock.counts",
+                            Href = "/dashboard/stock/counts",
+                            Label = "Counts",
+                            NavItemId = 6,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 37,
+                            Code = "stock.reorder-alerts",
+                            Href = "/dashboard/stock/reorder-alerts",
+                            Label = "Reorder Alerts",
+                            NavItemId = 6,
+                            SortOrder = 7,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 38,
+                            Code = "stock.wastage",
+                            Href = "/dashboard/stock/wastage",
+                            Label = "Wastage",
+                            NavItemId = 6,
+                            SortOrder = 8,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Property<int>("TicketId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TicketId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("TicketId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("support_tickets", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.Property<int>("MessageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("MessageId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsFromAdmin")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<int>("SenderUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TicketId")
+                        .HasColumnType("int");
+
+                    b.HasKey("MessageId");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("support_ticket_messages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxRate", b =>
+                {
+                    b.Property<int>("TaxRateId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxRateId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<decimal>("Percentage")
+                        .HasPrecision(5, 2)
+                        .HasColumnType("decimal(5,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("TaxRateId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("tax_rates", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            TaxRateId = 1,
+                            Code = "STANDARD",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Standard",
+                            Percentage = 15m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 2,
+                            Code = "ZERO",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Zero-Rated",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            TaxRateId = 3,
+                            Code = "EXEMPT",
+                            CreatedAt = new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Name = "Exempt",
+                            Percentage = 0m,
+                            RowVersion = 1u,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TaxSlab", b =>
+                {
+                    b.Property<int>("TaxSlabId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("TaxSlabId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("EffectiveFrom")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("EffectiveTo")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<decimal>("LowerBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Rate")
+                        .HasPrecision(6, 4)
+                        .HasColumnType("decimal(6,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal?>("UpperBound")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TaxSlabId");
+
+                    b.HasIndex("EffectiveFrom");
+
+                    b.ToTable("hr_tax_slabs", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Property<int>("StageId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StageId"));
+
+                    b.Property<int>("EstimatedMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FieldDefs")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<decimal>("PosX")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("PosY")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("RoleLabel")
+                        .HasMaxLength(60)
+                        .HasColumnType("varchar(60)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("StageId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("template_stages", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Uom", b =>
+                {
+                    b.Property<int>("UomId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UomId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("UomId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("uoms", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("UserId"));
+
+                    b.Property<Guid?>("AuthUserId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("auth_user_id");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(320)
+                        .HasColumnType("varchar(320)");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("AuthUserId")
+                        .IsUnique();
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            UserId = 1,
+                            DisplayName = "System",
+                            Status = "Active",
+                            Username = "system"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.Property<int>("VendorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("VendorId"));
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(3)
+                        .HasColumnType("varchar(3)")
+                        .HasDefaultValue("LKR");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<string>("TaxReg")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Terms")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("VendorId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("vendors", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Property<int>("QuotationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("RfqId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("QuotationId");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("RfqId", "VendorId")
+                        .IsUnique();
+
+                    b.ToTable("vendor_quotations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.Property<int>("QuotationLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("QuotationLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LeadDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("QuotationId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("QuotationLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("QuotationId");
+
+                    b.ToTable("vendor_quotation_lines", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Property<int>("WarehouseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarehouseId"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("WarehouseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("warehouses", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyPeriod", b =>
+                {
+                    b.Property<int>("WarrantyPeriodId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyPeriodId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Months")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyPeriodId");
+
+                    b.HasIndex("Months")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("warranty_periods", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_warranty_periods_months", "`Months` BETWEEN 1 AND 600");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
+                {
+                    b.Property<int>("WorkShiftId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WorkShiftId"));
+
+                    b.Property<int>("BreakMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("GraceMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsOvernight")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<decimal>("OtMultiplier")
+                        .HasPrecision(6, 2)
+                        .HasColumnType("decimal(6,2)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("StandardWorkingMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("WorkingDaysMask")
+                        .HasColumnType("int");
+
+                    b.HasKey("WorkShiftId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("hr_work_shifts", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.AttendanceUploadBatch", "AttendanceUploadBatch")
+                        .WithMany()
+                        .HasForeignKey("AttendanceUploadBatchId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AttendanceUploadBatch");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.AuditLog", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Bin", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany("Bins")
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BranchConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany()
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("BundleSales")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSale", "BundleSale")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSale");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplateLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.BundleSaleTemplate", "BundleSaleTemplate")
+                        .WithMany("Lines")
+                        .HasForeignKey("BundleSaleTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BundleSaleTemplate");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Customer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("DefaultWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Department", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "HeadEmployee")
+                        .WithMany()
+                        .HasForeignKey("HeadEmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "ParentDepartment")
+                        .WithMany()
+                        .HasForeignKey("ParentDepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("HeadEmployee");
+
+                    b.Navigation("ParentDepartment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.DocumentApproval", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Decider")
+                        .WithMany()
+                        .HasForeignKey("DecidedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Decider");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Department", "Department")
+                        .WithMany()
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Designation", "Designation")
+                        .WithMany()
+                        .HasForeignKey("DesignationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.EmploymentType", "EmploymentType")
+                        .WithMany()
+                        .HasForeignKey("EmploymentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "ReportingManager")
+                        .WithMany()
+                        .HasForeignKey("ReportingManagerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Employee", "UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.WorkShift", "WorkShift")
+                        .WithMany()
+                        .HasForeignKey("WorkShiftId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Department");
+
+                    b.Navigation("Designation");
+
+                    b.Navigation("EmploymentType");
+
+                    b.Navigation("ReportingManager");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkShift");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeBankDetail", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeDocument", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.HrDocumentType", "HrDocumentType")
+                        .WithMany()
+                        .HasForeignKey("HrDocumentTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("HrDocumentType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructureLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeSalaryStructure", "EmployeeSalaryStructure")
+                        .WithMany("Lines")
+                        .HasForeignKey("EmployeeSalaryStructureId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("EmployeeSalaryStructure");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany()
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany()
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany("Lines")
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PoLine", "PoLine")
+                        .WithMany()
+                        .HasForeignKey("PoLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PoLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("WarrantyNumbers")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "BaseUom")
+                        .WithMany()
+                        .HasForeignKey("BaseUomId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Brand", "Brand")
+                        .WithMany()
+                        .HasForeignKey("BrandId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "DefaultVendor")
+                        .WithMany()
+                        .HasForeignKey("DefaultVendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubCategory", "SubCategory")
+                        .WithMany()
+                        .HasForeignKey("SubCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TaxRate", "TaxRate")
+                        .WithMany()
+                        .HasForeignKey("TaxRateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("BaseUom");
+
+                    b.Navigation("Brand");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("DefaultVendor");
+
+                    b.Navigation("SubCategory");
+
+                    b.Navigation("TaxRate");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemImage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemPriceHistory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PriceAdjustment", "PriceAdjustment")
+                        .WithMany()
+                        .HasForeignKey("PriceAdjustmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PriceAdjustment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany("ReorderSettings")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveBalance", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LeaveRequest", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.LeaveType", "LeaveType")
+                        .WithMany()
+                        .HasForeignKey("LeaveTypeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("LeaveType");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoanInstallment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.EmployeeLoan", "EmployeeLoan")
+                        .WithMany("Installments")
+                        .HasForeignKey("EmployeeLoanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany()
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("EmployeeLoan");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.LoginActivity", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfigModule", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NotificationConfig", "NotificationConfig")
+                        .WithMany("Modules")
+                        .HasForeignKey("NotificationConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NotificationConfig");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationRecipient", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Notification", "Notification")
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notification");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NumberSequence", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PayrollRun", "PayrollRun")
+                        .WithMany("Lines")
+                        .HasForeignKey("PayrollRunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("PayrollRun");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLineComponent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithMany("Components")
+                        .HasForeignKey("PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalaryComponent", "SalaryComponent")
+                        .WithMany()
+                        .HasForeignKey("SalaryComponentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("PayrollLine");
+
+                    b.Navigation("SalaryComponent");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Payslip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.PayrollLine", "PayrollLine")
+                        .WithOne()
+                        .HasForeignKey("ERPCore.Domain.Entities.Payslip", "PayrollLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PayrollLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Permission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany()
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ERPCore.Domain.Entities.SubNavItem", "SubNavItem")
+                        .WithMany()
+                        .HasForeignKey("SubNavItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("NavItem");
+
+                    b.Navigation("SubNavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PoLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseOrder", "PurchaseOrder")
+                        .WithMany("Lines")
+                        .HasForeignKey("PoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PurchaseOrder");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PriceAdjustment", "PriceAdjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("PriceAdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PriceAdjustment");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "CancelReason")
+                        .WithMany()
+                        .HasForeignKey("CancelReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "OutputBin")
+                        .WithMany()
+                        .HasForeignKey("OutputBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Runs")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CancelReason");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("OutputBin");
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Grn", "Grn")
+                        .WithMany()
+                        .HasForeignKey("GrnId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Grn");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseInvoice", "PurchaseInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("PurchaseInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("PurchaseInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApproverUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Requisition");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PurchaseReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Requester")
+                        .WithMany()
+                        .HasForeignKey("RequestedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requester");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RequisitionLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany("Lines")
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Requisition", "Requisition")
+                        .WithMany()
+                        .HasForeignKey("RequisitionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Requisition");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RfqLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Lines")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Rfq");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RolePermission", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Permission", "Permission")
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Permission");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ChildRunStage")
+                        .WithMany()
+                        .HasForeignKey("ChildRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "ParentRunStage")
+                        .WithMany()
+                        .HasForeignKey("ParentRunStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Edges")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildRunStage");
+
+                    b.Navigation("ParentRunStage");
+
+                    b.Navigation("Run");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Stages")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "TemplateStage")
+                        .WithMany()
+                        .HasForeignKey("TemplateStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Run");
+
+                    b.Navigation("TemplateStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageEvent", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionRun", "Run")
+                        .WithMany("Events")
+                        .HasForeignKey("RunId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Events")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Run");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.RunStageOutput", "FromRunOutput")
+                        .WithMany()
+                        .HasForeignKey("FromRunOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromRunOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.RunStage", "RunStage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("RunStageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ScrapReason")
+                        .WithMany()
+                        .HasForeignKey("ScrapReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("RunStage");
+
+                    b.Navigation("ScrapReason");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesConfig", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "CashCustomer")
+                        .WithMany()
+                        .HasForeignKey("CashCustomerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DefaultWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DefaultWarehouseId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CashCustomer");
+
+                    b.Navigation("DefaultWarehouse");
+
+                    b.Navigation("UpdatedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "ClosedByUser")
+                        .WithMany()
+                        .HasForeignKey("ClosedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("ClosedByUser");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorUserId");
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesInvoice");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoice", "SalesInvoice")
+                        .WithMany("Payments")
+                        .HasForeignKey("SalesInvoiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("SalesInvoice");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturn", "Return")
+                        .WithMany("Lines")
+                        .HasForeignKey("ReturnId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany()
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Return");
+
+                    b.Navigation("SalesInvoiceLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
+                        .WithMany()
+                        .HasForeignKey("CashierUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesDayEnd", "DayEnd")
+                        .WithMany("Slips")
+                        .HasForeignKey("DayEndId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CashierUser");
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("DayEnd");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlip", "SalesSlip")
+                        .WithMany("Lines")
+                        .HasForeignKey("SalesSlipId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("SalesSlip");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ChildStage")
+                        .WithMany()
+                        .HasForeignKey("ChildStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "ParentStage")
+                        .WithMany()
+                        .HasForeignKey("ParentStageId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Edges")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildStage");
+
+                    b.Navigation("ParentStage");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageInput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StageOutput", "FromOutput")
+                        .WithMany()
+                        .HasForeignKey("FromOutputId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Inputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FromOutput");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StageOutput", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.TemplateStage", "Stage")
+                        .WithMany("Outputs")
+                        .HasForeignKey("StageId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Uom", "Uom")
+                        .WithMany()
+                        .HasForeignKey("UomId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Stage");
+
+                    b.Navigation("Uom");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ReasonCode", "ReasonCode")
+                        .WithMany()
+                        .HasForeignKey("ReasonCodeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("ReasonCode");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.StockAdjustment", "Adjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("AdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Adjustment");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCountLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockCount", "Count")
+                        .WithMany("Lines")
+                        .HasForeignKey("CountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Count");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLayer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockLedger", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", null)
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", null)
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "DestWarehouse")
+                        .WithMany()
+                        .HasForeignKey("DestWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "SrcWarehouse")
+                        .WithMany()
+                        .HasForeignKey("SrcWarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("DestWarehouse");
+
+                    b.Navigation("SrcWarehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("DestBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Bin", null)
+                        .WithMany()
+                        .HasForeignKey("SrcBinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransfer", "Transfer")
+                        .WithMany("Lines")
+                        .HasForeignKey("TransferId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Transfer");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Category", "Category")
+                        .WithMany("SubCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SubNavItem", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.NavItem", "NavItem")
+                        .WithMany("Children")
+                        .HasForeignKey("NavItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NavItem");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicketMessage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SupportTicket", "Ticket")
+                        .WithMany("Messages")
+                        .HasForeignKey("TicketId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Ticket");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ProductionTemplate", "Template")
+                        .WithMany("Stages")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.User", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Vendor", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Rfq", "Rfq")
+                        .WithMany("Quotations")
+                        .HasForeignKey("RfqId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Rfq");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotationLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.VendorQuotation", "Quotation")
+                        .WithMany("Lines")
+                        .HasForeignKey("QuotationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Quotation");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.BundleSaleTemplate", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Category", b =>
+                {
+                    b.Navigation("SubCategories");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeLoan", b =>
+                {
+                    b.Navigation("Installments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.EmployeeSalaryStructure", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
+                {
+                    b.Navigation("Serials");
+
+                    b.Navigation("WarrantyNumbers");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Item", b =>
+                {
+                    b.Navigation("ReorderSettings");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NavItem", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Notification", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.NotificationConfig", b =>
+                {
+                    b.Navigation("Modules");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollLine", b =>
+                {
+                    b.Navigation("Components");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PayrollRun", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Events");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ProductionTemplate", b =>
+                {
+                    b.Navigation("Edges");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Stages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PurchaseReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Requisition", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Rfq", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Quotations");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.RunStage", b =>
+                {
+                    b.Navigation("Events");
+
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesDayEnd", b =>
+                {
+                    b.Navigation("BundleSales");
+
+                    b.Navigation("Slips");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoice", b =>
+                {
+                    b.Navigation("Lines");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransfer", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.TemplateStage", b =>
+                {
+                    b.Navigation("Inputs");
+
+                    b.Navigation("Outputs");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.VendorQuotation", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.Warehouse", b =>
+                {
+                    b.Navigation("Bins");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/20261009070055_AddDualApproval.cs b/Backend/ERPCore/Migrations/20261009070055_AddDualApproval.cs
new file mode 100644
index 0000000..6f8b0e9
--- /dev/null
+++ b/Backend/ERPCore/Migrations/20261009070055_AddDualApproval.cs
@@ -0,0 +1,473 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddDualApproval : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Status",
+                table: "stock_adjustments",
+                type: "varchar(30)",
+                maxLength: 30,
+                nullable: false,
+                collation: "utf8mb4_unicode_ci",
+                oldClrType: typeof(string),
+                oldType: "varchar(20)",
+                oldMaxLength: 20)
+                .OldAnnotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "ApprovedLevel1At",
+                table: "stock_adjustments",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ApprovedLevel1By",
+                table: "stock_adjustments",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "ApprovedLevel2At",
+                table: "stock_adjustments",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ApprovedLevel2By",
+                table: "stock_adjustments",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CancelledAt",
+                table: "stock_adjustments",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "PostedAt",
+                table: "stock_adjustments",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "RejectReason",
+                table: "stock_adjustments",
+                type: "varchar(250)",
+                maxLength: 250,
+                nullable: true,
+                collation: "utf8mb4_unicode_ci");
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "RejectedAt",
+                table: "stock_adjustments",
+                type: "datetime(6)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "RejectedBy",
+                table: "stock_adjustments",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "RequiredApprovals",
+                table: "stock_adjustments",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<string>(
+                name: "RequestedSerialIds",
+                table: "stock_adjustment_lines",
+                type: "varchar(4000)",
+                maxLength: 4000,
+                nullable: true,
+                collation: "utf8mb4_unicode_ci");
+
+            migrationBuilder.AddColumn<string>(
+                name: "RequestedSerialNos",
+                table: "stock_adjustment_lines",
+                type: "varchar(4000)",
+                maxLength: 4000,
+                nullable: true,
+                collation: "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "approval_config",
+                columns: table => new
+                {
+                    ApprovalConfigId = table.Column<int>(type: "int", nullable: false),
+                    StockAdjustmentLevels = table.Column<int>(type: "int", nullable: false),
+                    StockAdjustmentLevel2ThresholdValue = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: false),
+                    PriceAdjustmentLevels = table.Column<int>(type: "int", nullable: false),
+                    PriceAdjustmentLevel2ThresholdPercent = table.Column<decimal>(type: "decimal(9,4)", precision: 9, scale: 4, nullable: false),
+                    Level2RoleCodes = table.Column<string>(type: "varchar(500)", maxLength: 500, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    UpdatedBy = table.Column<int>(type: "int", nullable: true),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_approval_config", x => x.ApprovalConfigId);
+                    table.CheckConstraint("ck_approval_config_singleton", "`ApprovalConfigId` = 1");
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "document_approvals",
+                columns: table => new
+                {
+                    DocumentApprovalId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    DocType = table.Column<string>(type: "varchar(10)", maxLength: 10, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    DocId = table.Column<int>(type: "int", nullable: false),
+                    Level = table.Column<int>(type: "int", nullable: false),
+                    Decision = table.Column<string>(type: "varchar(20)", maxLength: 20, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    DecidedBy = table.Column<int>(type: "int", nullable: false),
+                    DecidedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    Comment = table.Column<string>(type: "varchar(250)", maxLength: 250, nullable: true, collation: "utf8mb4_unicode_ci")
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_document_approvals", x => x.DocumentApprovalId);
+                    table.ForeignKey(
+                        name: "FK_document_approvals_users_DecidedBy",
+                        column: x => x.DecidedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "price_adjustments",
+                columns: table => new
+                {
+                    PriceAdjustmentId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    DocNo = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    Reason = table.Column<string>(type: "varchar(250)", maxLength: 250, nullable: false, collation: "utf8mb4_unicode_ci"),
+                    Status = table.Column<string>(type: "varchar(30)", maxLength: 30, nullable: false, defaultValue: "PendingApproval", collation: "utf8mb4_unicode_ci"),
+                    RequiredApprovals = table.Column<int>(type: "int", nullable: false),
+                    CreatedBy = table.Column<int>(type: "int", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false),
+                    ApprovedLevel1By = table.Column<int>(type: "int", nullable: true),
+                    ApprovedLevel1At = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    ApprovedLevel2By = table.Column<int>(type: "int", nullable: true),
+                    ApprovedLevel2At = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RejectedBy = table.Column<int>(type: "int", nullable: true),
+                    RejectedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RejectReason = table.Column<string>(type: "varchar(250)", maxLength: 250, nullable: true, collation: "utf8mb4_unicode_ci"),
+                    CancelledAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    AppliedAt = table.Column<DateTime>(type: "datetime(6)", nullable: true),
+                    RowVersion = table.Column<uint>(type: "int unsigned", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_price_adjustments", x => x.PriceAdjustmentId);
+                    table.ForeignKey(
+                        name: "FK_price_adjustments_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "item_price_history",
+                columns: table => new
+                {
+                    ItemPriceHistoryId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    ItemId = table.Column<int>(type: "int", nullable: false),
+                    PriceAdjustmentId = table.Column<int>(type: "int", nullable: true),
+                    OldMinPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    OldMaxPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    OldFlatPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    NewMinPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    NewMaxPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    NewFlatPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    RequestedBy = table.Column<int>(type: "int", nullable: false),
+                    ApprovedLevel1By = table.Column<int>(type: "int", nullable: true),
+                    ApprovedLevel2By = table.Column<int>(type: "int", nullable: true),
+                    AppliedAt = table.Column<DateTime>(type: "datetime(6)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_item_price_history", x => x.ItemPriceHistoryId);
+                    table.ForeignKey(
+                        name: "FK_item_price_history_items_ItemId",
+                        column: x => x.ItemId,
+                        principalTable: "items",
+                        principalColumn: "ItemId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_item_price_history_price_adjustments_PriceAdjustmentId",
+                        column: x => x.PriceAdjustmentId,
+                        principalTable: "price_adjustments",
+                        principalColumn: "PriceAdjustmentId",
+                        onDelete: ReferentialAction.Restrict);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.CreateTable(
+                name: "price_adjustment_lines",
+                columns: table => new
+                {
+                    PriceAdjustmentLineId = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    PriceAdjustmentId = table.Column<int>(type: "int", nullable: false),
+                    ItemId = table.Column<int>(type: "int", nullable: false),
+                    OldMinPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    OldMaxPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    OldFlatPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    NewMinPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    NewMaxPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true),
+                    NewFlatPrice = table.Column<decimal>(type: "decimal(18,4)", precision: 18, scale: 4, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_price_adjustment_lines", x => x.PriceAdjustmentLineId);
+                    table.ForeignKey(
+                        name: "FK_price_adjustment_lines_items_ItemId",
+                        column: x => x.ItemId,
+                        principalTable: "items",
+                        principalColumn: "ItemId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_price_adjustment_lines_price_adjustments_PriceAdjustmentId",
+                        column: x => x.PriceAdjustmentId,
+                        principalTable: "price_adjustments",
+                        principalColumn: "PriceAdjustmentId",
+                        onDelete: ReferentialAction.Cascade);
+                })
+                .Annotation("Relational:Collation", "utf8mb4_unicode_ci");
+
+            migrationBuilder.InsertData(
+                table: "approval_config",
+                columns: new[] { "ApprovalConfigId", "Level2RoleCodes", "PriceAdjustmentLevel2ThresholdPercent", "PriceAdjustmentLevels", "RowVersion", "StockAdjustmentLevel2ThresholdValue", "StockAdjustmentLevels", "UpdatedAt", "UpdatedBy" },
+                values: new object[] { 1, null, 0m, 2, 1u, 0m, 2, null, null });
+
+            migrationBuilder.InsertData(
+                table: "sub_nav_items",
+                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
+                values: new object[,]
+                {
+                    { 48, "products.price-adjustments", "/dashboard/products/price-adjustments", null, "Price Adjustments", 2, 8 },
+                    { 49, "settings.approvals", "/dashboard/settings/approvals", null, "Approvals", 9, 4 }
+                });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[,]
+                {
+                    { 58, "NAV:products.price-adjustments", null, 48 },
+                    { 59, "NAV:settings.approvals", null, 49 }
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_stock_adjustments_Status",
+                table: "stock_adjustments",
+                column: "Status");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_document_approvals_DecidedBy",
+                table: "document_approvals",
+                column: "DecidedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_document_approvals_DocType_DocId",
+                table: "document_approvals",
+                columns: new[] { "DocType", "DocId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_item_price_history_ItemId_AppliedAt",
+                table: "item_price_history",
+                columns: new[] { "ItemId", "AppliedAt" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_item_price_history_PriceAdjustmentId",
+                table: "item_price_history",
+                column: "PriceAdjustmentId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_price_adjustment_lines_ItemId",
+                table: "price_adjustment_lines",
+                column: "ItemId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_price_adjustment_lines_PriceAdjustmentId",
+                table: "price_adjustment_lines",
+                column: "PriceAdjustmentId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_price_adjustments_CreatedBy",
+                table: "price_adjustments",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_price_adjustments_DocNo",
+                table: "price_adjustments",
+                column: "DocNo",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_price_adjustments_Status",
+                table: "price_adjustments",
+                column: "Status");
+
+            // Existing adjustments all auto-posted, so they need no approval rows — RequiredApprovals = 0
+            // (the column default) marks them as "posted without approval".
+
+            // Price Adjustments (58): Admin and every role that already reaches Products (NAV:products 2,
+            // products.item 11). Approval settings (59): Admin only. Actions 31 = all, including Approve —
+            // admins should narrow Approve to the people who really approve (at least two per branch).
+            migrationBuilder.Sql("""
+                INSERT IGNORE INTO `role_permissions` (`RoleId`, `PermissionId`, `Actions`)
+                SELECT r.`RoleId`, 58, 31
+                FROM `roles` r
+                WHERE LOWER(r.`Code`) = 'admin'
+                   OR EXISTS (SELECT 1 FROM `role_permissions` rp
+                              WHERE rp.`RoleId` = r.`RoleId` AND rp.`PermissionId` IN (2, 11));
+                """);
+            migrationBuilder.Sql("""
+                INSERT IGNORE INTO `role_permissions` (`RoleId`, `PermissionId`, `Actions`)
+                SELECT r.`RoleId`, 59, 31 FROM `roles` r WHERE LOWER(r.`Code`) = 'admin';
+                """);
+
+            // The approval notifications are on in the bell by default — without them nobody learns a
+            // request is waiting. Same guarded insert as EnableLowStockAlerts.
+            foreach (var key in new[] { "approval.pending", "approval.approved", "approval.rejected" })
+            {
+                migrationBuilder.Sql($"""
+                    INSERT INTO `notification_config_modules` (`NotificationConfigId`, `ModuleKey`, `EmailEnabled`, `SmsEnabled`, `InAppEnabled`)
+                    SELECT c.`NotificationConfigId`, '{key}', 0, 0, 1
+                    FROM `notification_config` c
+                    WHERE c.`NotificationConfigId` = 1
+                      AND NOT EXISTS (SELECT 1 FROM `notification_config_modules` m WHERE m.`ModuleKey` = '{key}');
+                    """);
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("DELETE FROM `role_permissions` WHERE `PermissionId` IN (58, 59);");
+            migrationBuilder.Sql("DELETE FROM `notification_config_modules` WHERE `ModuleKey` IN ('approval.pending', 'approval.approved', 'approval.rejected');");
+
+            migrationBuilder.DropTable(
+                name: "approval_config");
+
+            migrationBuilder.DropTable(
+                name: "document_approvals");
+
+            migrationBuilder.DropTable(
+                name: "item_price_history");
+
+            migrationBuilder.DropTable(
+                name: "price_adjustment_lines");
+
+            migrationBuilder.DropTable(
+                name: "price_adjustments");
+
+            migrationBuilder.DropIndex(
+                name: "IX_stock_adjustments_Status",
+                table: "stock_adjustments");
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 58);
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 59);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 48);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 49);
+
+            migrationBuilder.DropColumn(
+                name: "ApprovedLevel1At",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "ApprovedLevel1By",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "ApprovedLevel2At",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "ApprovedLevel2By",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "CancelledAt",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "PostedAt",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "RejectReason",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "RejectedAt",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "RejectedBy",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "RequiredApprovals",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "RequestedSerialIds",
+                table: "stock_adjustment_lines");
+
+            migrationBuilder.DropColumn(
+                name: "RequestedSerialNos",
+                table: "stock_adjustment_lines");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Status",
+                table: "stock_adjustments",
+                type: "varchar(20)",
+                maxLength: 20,
+                nullable: false,
+                collation: "utf8mb4_unicode_ci",
+                oldClrType: typeof(string),
+                oldType: "varchar(30)",
+                oldMaxLength: 30)
+                .OldAnnotation("Relational:Collation", "utf8mb4_unicode_ci");
+        }
+    }
+}
diff --git a/Backend/ERPCore/Migrations/ErpDbContextModelSnapshot.cs b/Backend/ERPCore/Migrations/ErpDbContextModelSnapshot.cs
index 59f4860..5e03eaf 100644
--- a/Backend/ERPCore/Migrations/ErpDbContextModelSnapshot.cs
+++ b/Backend/ERPCore/Migrations/ErpDbContextModelSnapshot.cs
@@ -1,4 +1,4 @@
-// <auto-generated />
+// <auto-generated />
 using System;
 using ERPCore.Infra.Persistence;
 using Microsoft.EntityFrameworkCore;
@@ -23,6 +23,58 @@ namespace ERPCore.Migrations
 
             MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.ApprovalConfig", b =>
+                {
+                    b.Property<int>("ApprovalConfigId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Level2RoleCodes")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<decimal>("PriceAdjustmentLevel2ThresholdPercent")
+                        .HasPrecision(9, 4)
+                        .HasColumnType("decimal(9,4)");
+
+                    b.Property<int>("PriceAdjustmentLevels")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<decimal>("StockAdjustmentLevel2ThresholdValue")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("StockAdjustmentLevels")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("UpdatedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ApprovalConfigId");
+
+                    b.ToTable("approval_config", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_approval_config_singleton", "`ApprovalConfigId` = 1");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            ApprovalConfigId = 1,
+                            PriceAdjustmentLevel2ThresholdPercent = 0m,
+                            PriceAdjustmentLevels = 2,
+                            RowVersion = 1u,
+                            StockAdjustmentLevel2ThresholdValue = 0m,
+                            StockAdjustmentLevels = 2
+                        });
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.AttendanceRecord", b =>
                 {
                     b.Property<int>("AttendanceRecordId")
@@ -214,6 +266,133 @@ namespace ERPCore.Migrations
                     b.ToTable("audit_logs", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.Property<int>("BankDepositId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("BankDepositId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("CancelledBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("DepositDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("DepositSlipNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("DepositedBy")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("FromCashAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("FromCashAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<long>("FromGlCashAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("Remarks")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Posted");
+
+                    b.Property<string>("ToAccountNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("ToBankAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("ToBankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ToBankName")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<long>("ToGlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("BankDepositId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ToGlBankAccountId");
+
+                    b.HasIndex("BranchId", "BusinessDate", "Status");
+
+                    b.ToTable("bank_deposits", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_bank_deposits_amount", "`Amount` > 0");
+                        });
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
                 {
                     b.Property<int>("BatchId")
@@ -435,6 +614,14 @@ namespace ERPCore.Migrations
                     b.Property<int>("BundleSaleTemplateId")
                         .HasColumnType("int");
 
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
                     b.Property<int>("CashierUserId")
                         .HasColumnType("int");
 
@@ -904,6 +1091,49 @@ namespace ERPCore.Migrations
                     b.ToTable("hr_designations", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.DocumentApproval", b =>
+                {
+                    b.Property<int>("DocumentApprovalId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("DocumentApprovalId"));
+
+                    b.Property<string>("Comment")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("DecidedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DecidedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Decision")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("DocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocType")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("int");
+
+                    b.HasKey("DocumentApprovalId");
+
+                    b.HasIndex("DecidedBy");
+
+                    b.HasIndex("DocType", "DocId");
+
+                    b.ToTable("document_approvals", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
                 {
                     b.Property<int>("EmployeeId")
@@ -1421,6 +1651,564 @@ namespace ERPCore.Migrations
                     b.ToTable("hr_employment_types", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Property<int>("ExpenseId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("BalanceAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BillReference")
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("BranchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CancelReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("ExpenseDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ExpenseTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime?>("GlPostedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("GlReversalJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<decimal>("PaidAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("Payee")
+                        .HasMaxLength(150)
+                        .HasColumnType("varchar(150)");
+
+                    b.Property<string>("PaymentStatus")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Unpaid");
+
+                    b.Property<string>("PeriodMonth")
+                        .HasMaxLength(7)
+                        .HasColumnType("varchar(7)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Draft");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("VendorId")
+                        .HasColumnType("int");
+
+                    b.HasKey("ExpenseId");
+
+                    b.HasIndex("BranchId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("ExpenseCategoryId");
+
+                    b.HasIndex("ExpenseDate");
+
+                    b.HasIndex("ExpenseTitleId");
+
+                    b.HasIndex("PaymentStatus");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("expenses", null, t =>
+                        {
+                            t.HasCheckConstraint("ck_expenses_amount", "`Amount` > 0");
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Property<int>("ExpenseCategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseCategoryId"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseCategoryId");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_categories", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseCategoryId = 1,
+                            Code = "UTILITY",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Utility",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 2,
+                            Code = "RENTAL",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Rental",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 3,
+                            Code = "SALARIES",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseCategoryId = 4,
+                            Code = "OTHER",
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            IsSystem = true,
+                            Name = "Other",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        });
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.Property<int>("ExpensePaymentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpensePaymentId"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<string>("BankAccountName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ChequeNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ExpenseId")
+                        .HasColumnType("int");
+
+                    b.Property<long>("GlBankAccountId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("GlJournalNo")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<DateTime>("PaymentDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("ExpensePaymentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ExpenseId");
+
+                    b.ToTable("expense_payments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.Property<int>("ExpenseTitleId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ExpenseTitleId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ExpenseCategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("GlExpenseAccountCode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Active");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ExpenseTitleId");
+
+                    b.HasIndex("ExpenseCategoryId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("expense_titles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            ExpenseTitleId = 1,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Electricity",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 2,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Water",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 3,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Telephone",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 4,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Internet",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 5,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 1,
+                            GlExpenseAccountCode = "5200-01",
+                            IsSystem = true,
+                            Name = "Gas",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 6,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Building Rent",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 7,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Vehicle Rent",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 8,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 2,
+                            GlExpenseAccountCode = "5200-02",
+                            IsSystem = true,
+                            Name = "Equipment Rent",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 9,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Staff Salaries",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 10,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Wages",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 11,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Overtime",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 12,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "Bonus",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 13,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 3,
+                            GlExpenseAccountCode = "5200-03",
+                            IsSystem = true,
+                            Name = "EPF / ETF Contribution",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 14,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Stationery",
+                            RowVersion = 1u,
+                            SortOrder = 1,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 15,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Transport",
+                            RowVersion = 1u,
+                            SortOrder = 2,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 16,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Repairs & Maintenance",
+                            RowVersion = 1u,
+                            SortOrder = 3,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 17,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Cleaning",
+                            RowVersion = 1u,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            ExpenseTitleId = 18,
+                            CreatedAt = new DateTime(2026, 10, 7, 0, 0, 0, 0, DateTimeKind.Utc),
+                            ExpenseCategoryId = 4,
+                            GlExpenseAccountCode = "5200-04",
+                            IsSystem = true,
+                            Name = "Miscellaneous",
+                            RowVersion = 1u,
+                            SortOrder = 5,
+                            Status = "Active"
+                        });
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.GlAccountConfig", b =>
                 {
                     b.Property<int>("ConfigId")
@@ -1693,6 +2481,35 @@ namespace ERPCore.Migrations
                     b.ToTable("grn_lines", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.Property<int>("GrnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("GrnLineSerialId"));
+
+                    b.Property<int>("GrnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SerialNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.HasKey("GrnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("GrnLineId", "SerialNo")
+                        .IsUnique();
+
+                    b.ToTable("grn_line_serials", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
                 {
                     b.Property<int>("GrnLineWarrantyNumberId")
@@ -1960,6 +2777,65 @@ namespace ERPCore.Migrations
                     b.ToTable("item_images", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemPriceHistory", b =>
+                {
+                    b.Property<int>("ItemPriceHistoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ItemPriceHistoryId"));
+
+                    b.Property<DateTime>("AppliedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel1By")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ApprovedLevel2By")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NewFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("PriceAdjustmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RequestedBy")
+                        .HasColumnType("int");
+
+                    b.HasKey("ItemPriceHistoryId");
+
+                    b.HasIndex("PriceAdjustmentId");
+
+                    b.HasIndex("ItemId", "AppliedAt");
+
+                    b.ToTable("item_price_history", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
                 {
                     b.Property<int>("ReorderId")
@@ -3314,6 +4190,42 @@ namespace ERPCore.Migrations
                             PermissionId = 53,
                             Code = "NAV:products.tax-rates",
                             SubNavItemId = 43
+                        },
+                        new
+                        {
+                            PermissionId = 54,
+                            Code = "NAV:accounts.expenses",
+                            SubNavItemId = 44
+                        },
+                        new
+                        {
+                            PermissionId = 55,
+                            Code = "NAV:accounts.expense-setup",
+                            SubNavItemId = 45
+                        },
+                        new
+                        {
+                            PermissionId = 56,
+                            Code = "NAV:sales.day-end-report",
+                            SubNavItemId = 46
+                        },
+                        new
+                        {
+                            PermissionId = 57,
+                            Code = "NAV:accounts.bank-deposits",
+                            SubNavItemId = 47
+                        },
+                        new
+                        {
+                            PermissionId = 58,
+                            Code = "NAV:products.price-adjustments",
+                            SubNavItemId = 48
+                        },
+                        new
+                        {
+                            PermissionId = 59,
+                            Code = "NAV:settings.approvals",
+                            SubNavItemId = 49
                         });
                 });
 
@@ -3361,6 +4273,131 @@ namespace ERPCore.Migrations
                     b.ToTable("po_lines", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustment", b =>
+                {
+                    b.Property<int>("PriceAdjustmentId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PriceAdjustmentId"));
+
+                    b.Property<DateTime?>("AppliedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ApprovedLevel1At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel1By")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ApprovedLevel2At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel2By")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CreatedBy")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocNo")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<string>("RejectReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("RejectedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("RejectedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RequiredApprovals")
+                        .HasColumnType("int");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)")
+                        .HasDefaultValue("PendingApproval");
+
+                    b.HasKey("PriceAdjustmentId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("DocNo")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("price_adjustments", (string)null);
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustmentLine", b =>
+                {
+                    b.Property<int>("PriceAdjustmentLineId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("PriceAdjustmentLineId"));
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NewFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("NewMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldFlatPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMaxPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal?>("OldMinPrice")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int>("PriceAdjustmentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("PriceAdjustmentLineId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("PriceAdjustmentId");
+
+                    b.ToTable("price_adjustment_lines", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
                 {
                     b.Property<int>("ConfigId")
@@ -4740,6 +5777,9 @@ namespace ERPCore.Migrations
                         .HasPrecision(18, 4)
                         .HasColumnType("decimal(18,4)");
 
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
                     b.Property<string>("Description")
                         .IsRequired()
                         .HasMaxLength(200)
@@ -4810,6 +5850,8 @@ namespace ERPCore.Migrations
 
                     b.HasKey("SalesInvoiceLineId");
 
+                    b.HasIndex("BatchId");
+
                     b.HasIndex("ItemId");
 
                     b.HasIndex("SalesInvoiceId");
@@ -4819,6 +5861,30 @@ namespace ERPCore.Migrations
                     b.ToTable("sales_invoice_lines", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.Property<int>("SalesInvoiceLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesInvoiceLineSerialId"));
+
+                    b.Property<int>("SalesInvoiceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesInvoiceLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesInvoiceLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_invoice_line_serials", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
                 {
                     b.Property<int>("SalesInvoicePaymentId")
@@ -4852,6 +5918,13 @@ namespace ERPCore.Migrations
                     b.Property<DateTime>("PaymentDate")
                         .HasColumnType("datetime(6)");
 
+                    b.Property<string>("PaymentMethod")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasDefaultValue("Cash");
+
                     b.Property<string>("Reference")
                         .HasMaxLength(100)
                         .HasColumnType("varchar(100)");
@@ -4868,6 +5941,63 @@ namespace ERPCore.Migrations
                     b.ToTable("sales_invoice_payments", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.Property<int>("SalesLineAllocationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesLineAllocationId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("QtyReturned")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesLineAllocationId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId", "SourceLineId");
+
+                    b.ToTable("sales_line_allocations", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
                 {
                     b.Property<int>("ReturnId")
@@ -4932,6 +6062,9 @@ namespace ERPCore.Migrations
 
                     MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("ReturnLineId"));
 
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
                     b.Property<int>("ItemId")
                         .HasColumnType("int");
 
@@ -4947,6 +6080,8 @@ namespace ERPCore.Migrations
 
                     b.HasKey("ReturnLineId");
 
+                    b.HasIndex("BatchId");
+
                     b.HasIndex("ItemId");
 
                     b.HasIndex("ReturnId");
@@ -4956,6 +6091,30 @@ namespace ERPCore.Migrations
                     b.ToTable("sales_return_lines", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.Property<int>("SalesReturnLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesReturnLineSerialId"));
+
+                    b.Property<int>("ReturnLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesReturnLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("ReturnLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_return_line_serials", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
                 {
                     b.Property<int>("SalesSlipId")
@@ -4968,6 +6127,14 @@ namespace ERPCore.Migrations
                         .HasPrecision(18, 4)
                         .HasColumnType("decimal(18,4)");
 
+                    b.Property<decimal>("CardAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<decimal>("CashAmount")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
                     b.Property<int>("CashierUserId")
                         .HasColumnType("int");
 
@@ -5151,6 +6318,30 @@ namespace ERPCore.Migrations
                     b.ToTable("sales_slip_lines", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.Property<int>("SalesSlipLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SalesSlipLineSerialId"));
+
+                    b.Property<int>("SalesSlipLineId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SalesSlipLineSerialId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SalesSlipLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("sales_slip_line_serials", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
                 {
                     b.Property<int>("SerialId")
@@ -5163,9 +6354,25 @@ namespace ERPCore.Migrations
                         .HasMaxLength(100)
                         .HasColumnType("varchar(100)");
 
+                    b.Property<int?>("BinId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("GrnLineId")
+                        .HasColumnType("int");
+
                     b.Property<int>("ItemId")
                         .HasColumnType("int");
 
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
                     b.Property<string>("SerialNo")
                         .IsRequired()
                         .HasMaxLength(100)
@@ -5176,17 +6383,79 @@ namespace ERPCore.Migrations
                         .HasMaxLength(20)
                         .HasColumnType("varchar(20)");
 
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarrantyPeriodMonths")
+                        .HasColumnType("int");
+
                     b.HasKey("SerialId");
 
                     b.HasIndex("Barcode")
                         .IsUnique();
 
+                    b.HasIndex("BinId");
+
+                    b.HasIndex("GrnLineId");
+
                     b.HasIndex("ItemId", "SerialNo")
                         .IsUnique();
 
+                    b.HasIndex("ItemId", "Status");
+
+                    b.HasIndex("WarehouseId", "ItemId", "Status");
+
                     b.ToTable("serials", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.Property<int>("SerialMovementId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("SerialMovementId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("FromWarehouseId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WarehouseId")
+                        .HasColumnType("int");
+
+                    b.HasKey("SerialMovementId");
+
+                    b.HasIndex("SerialId", "SerialMovementId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.ToTable("serial_movements", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
                 {
                     b.Property<int>("EdgeId")
@@ -5303,9 +6572,24 @@ namespace ERPCore.Migrations
 
                     MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("AdjustmentId"));
 
+                    b.Property<DateTime?>("ApprovedLevel1At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel1By")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ApprovedLevel2At")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("ApprovedLevel2By")
+                        .HasColumnType("int");
+
                     b.Property<int>("BranchId")
                         .HasColumnType("int");
 
+                    b.Property<DateTime?>("CancelledAt")
+                        .HasColumnType("datetime(6)");
+
                     b.Property<DateTime>("CreatedAt")
                         .HasColumnType("datetime(6)");
 
@@ -5324,17 +6608,33 @@ namespace ERPCore.Migrations
                     b.Property<DateTime?>("GlPostedAt")
                         .HasColumnType("datetime(6)");
 
+                    b.Property<DateTime?>("PostedAt")
+                        .HasColumnType("datetime(6)");
+
                     b.Property<int>("ReasonCodeId")
                         .HasColumnType("int");
 
+                    b.Property<string>("RejectReason")
+                        .HasMaxLength(250)
+                        .HasColumnType("varchar(250)");
+
+                    b.Property<DateTime?>("RejectedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("RejectedBy")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RequiredApprovals")
+                        .HasColumnType("int");
+
                     b.Property<uint>("RowVersion")
                         .IsConcurrencyToken()
                         .HasColumnType("int unsigned");
 
                     b.Property<string>("Status")
                         .IsRequired()
-                        .HasMaxLength(20)
-                        .HasColumnType("varchar(20)");
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)");
 
                     b.Property<int>("WarehouseId")
                         .HasColumnType("int");
@@ -5350,6 +6650,8 @@ namespace ERPCore.Migrations
 
                     b.HasIndex("ReasonCodeId");
 
+                    b.HasIndex("Status");
+
                     b.HasIndex("WarehouseId");
 
                     b.ToTable("stock_adjustments", (string)null);
@@ -5379,6 +6681,14 @@ namespace ERPCore.Migrations
                         .HasPrecision(18, 4)
                         .HasColumnType("decimal(18,4)");
 
+                    b.Property<string>("RequestedSerialIds")
+                        .HasMaxLength(4000)
+                        .HasColumnType("varchar(4000)");
+
+                    b.Property<string>("RequestedSerialNos")
+                        .HasMaxLength(4000)
+                        .HasColumnType("varchar(4000)");
+
                     b.Property<int?>("SerialId")
                         .HasColumnType("int");
 
@@ -5744,6 +7054,42 @@ namespace ERPCore.Migrations
                     b.ToTable("stock_transfer_lines", (string)null);
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.Property<int>("StockTransferLineSerialId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("StockTransferLineSerialId"));
+
+                    b.Property<int?>("BatchId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ReceivedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransferLineId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UnitCost")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("StockTransferLineSerialId");
+
+                    b.HasIndex("BatchId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("TransferLineId", "SerialId")
+                        .IsUnique();
+
+                    b.ToTable("stock_transfer_line_serials", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
                 {
                     b.Property<int>("SubCategoryId")
@@ -5907,6 +7253,16 @@ namespace ERPCore.Migrations
                             Status = "Active"
                         },
                         new
+                        {
+                            SubNavItemId = 48,
+                            Code = "products.price-adjustments",
+                            Href = "/dashboard/products/price-adjustments",
+                            Label = "Price Adjustments",
+                            NavItemId = 2,
+                            SortOrder = 8,
+                            Status = "Active"
+                        },
+                        new
                         {
                             SubNavItemId = 29,
                             Code = "settings.branches",
@@ -5947,6 +7303,16 @@ namespace ERPCore.Migrations
                             Status = "Active"
                         },
                         new
+                        {
+                            SubNavItemId = 49,
+                            Code = "settings.approvals",
+                            Href = "/dashboard/settings/approvals",
+                            Label = "Approvals",
+                            NavItemId = 9,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
                         {
                             SubNavItemId = 40,
                             Code = "sales.invoices",
@@ -5981,12 +7347,22 @@ namespace ERPCore.Migrations
                             SubNavItemId = 42,
                             Code = "sales.day-end",
                             Href = "/dashboard/sales/day-end",
-                            Label = "Day End",
+                            Label = "Approved Invoices",
                             NavItemId = 13,
                             SortOrder = 4,
                             Status = "Active"
                         },
                         new
+                        {
+                            SubNavItemId = 46,
+                            Code = "sales.day-end-report",
+                            Href = "/dashboard/sales/day-end-report",
+                            Label = "Day-End Report",
+                            NavItemId = 13,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
                         {
                             SubNavItemId = 30,
                             Code = "procurement.vendors",
@@ -6147,6 +7523,36 @@ namespace ERPCore.Migrations
                             Status = "Active"
                         },
                         new
+                        {
+                            SubNavItemId = 44,
+                            Code = "accounts.expenses",
+                            Href = "/dashboard/accounts/expenses",
+                            Label = "Expenses",
+                            NavItemId = 12,
+                            SortOrder = 4,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 45,
+                            Code = "accounts.expense-setup",
+                            Href = "/dashboard/accounts/expense-setup",
+                            Label = "Expense Setup",
+                            NavItemId = 12,
+                            SortOrder = 5,
+                            Status = "Active"
+                        },
+                        new
+                        {
+                            SubNavItemId = 47,
+                            Code = "accounts.bank-deposits",
+                            Href = "/dashboard/accounts/bank-deposits",
+                            Label = "Bank Deposits",
+                            NavItemId = 12,
+                            SortOrder = 6,
+                            Status = "Active"
+                        },
+                        new
                         {
                             SubNavItemId = 27,
                             Code = "production.templates",
@@ -6787,6 +8193,77 @@ namespace ERPCore.Migrations
                         });
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.Property<int>("WarrantyRegistrationId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("WarrantyRegistrationId"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("CustomerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("ItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PeriodMonths")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Qty")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("int unsigned");
+
+                    b.Property<int?>("SerialId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SourceDocId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceDocType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("SourceLineId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("WarrantyRegistrationId");
+
+                    b.HasIndex("CustomerId");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("SerialId");
+
+                    b.HasIndex("SourceDocType", "SourceDocId");
+
+                    b.HasIndex("Status", "EndDate");
+
+                    b.ToTable("warranty_registrations", (string)null);
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.WorkShift", b =>
                 {
                     b.Property<int>("WorkShiftId")
@@ -6892,6 +8369,25 @@ namespace ERPCore.Migrations
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.BankDeposit", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Creator");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Batch", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.Item", "Item")
@@ -7062,6 +8558,17 @@ namespace ERPCore.Migrations
                     b.Navigation("ParentDepartment");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.DocumentApproval", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Decider")
+                        .WithMany()
+                        .HasForeignKey("DecidedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Decider");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Employee", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
@@ -7190,6 +8697,78 @@ namespace ERPCore.Migrations
                     b.Navigation("SalaryComponent");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Branch", "Branch")
+                        .WithMany()
+                        .HasForeignKey("BranchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseTitle", "Title")
+                        .WithMany()
+                        .HasForeignKey("ExpenseTitleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Branch");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Title");
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpensePayment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Expense", "Expense")
+                        .WithMany("Payments")
+                        .HasForeignKey("ExpenseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Expense");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseTitle", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.ExpenseCategory", "Category")
+                        .WithMany("Titles")
+                        .HasForeignKey("ExpenseCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Category");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.GlAccountConfig", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
@@ -7306,6 +8885,24 @@ namespace ERPCore.Migrations
                     b.Navigation("PoLine");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("GrnLine");
+
+                    b.Navigation("Serial");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.GrnLineWarrantyNumber", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
@@ -7375,6 +8972,24 @@ namespace ERPCore.Migrations
                     b.Navigation("Item");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.ItemPriceHistory", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PriceAdjustment", "PriceAdjustment")
+                        .WithMany()
+                        .HasForeignKey("PriceAdjustmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PriceAdjustment");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.ItemReorder", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.Item", "Item")
@@ -7614,6 +9229,36 @@ namespace ERPCore.Migrations
                     b.Navigation("Warehouse");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustment", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustmentLine", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.PriceAdjustment", "PriceAdjustment")
+                        .WithMany("Lines")
+                        .HasForeignKey("PriceAdjustmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("PriceAdjustment");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.ProductConfig", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.User", "UpdatedByUser")
@@ -8143,6 +9788,11 @@ namespace ERPCore.Migrations
 
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
                 {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
                     b.HasOne("ERPCore.Domain.Entities.Item", "Item")
                         .WithMany()
                         .HasForeignKey("ItemId")
@@ -8161,6 +9811,8 @@ namespace ERPCore.Migrations
                         .OnDelete(DeleteBehavior.Restrict)
                         .IsRequired();
 
+                    b.Navigation("Batch");
+
                     b.Navigation("Item");
 
                     b.Navigation("SalesInvoice");
@@ -8168,6 +9820,25 @@ namespace ERPCore.Migrations
                     b.Navigation("Warehouse");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesInvoiceLine", "SalesInvoiceLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesInvoiceLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesInvoiceLine");
+
+                    b.Navigation("Serial");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoicePayment", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.User", "Creator")
@@ -8187,6 +9858,23 @@ namespace ERPCore.Migrations
                     b.Navigation("SalesInvoice");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesLineAllocation", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Batch");
+
+                    b.Navigation("Serial");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.User", "Creator")
@@ -8224,6 +9912,11 @@ namespace ERPCore.Migrations
 
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
                 {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", "Batch")
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
                     b.HasOne("ERPCore.Domain.Entities.Item", "Item")
                         .WithMany()
                         .HasForeignKey("ItemId")
@@ -8241,6 +9934,8 @@ namespace ERPCore.Migrations
                         .HasForeignKey("SalesInvoiceLineId")
                         .OnDelete(DeleteBehavior.Restrict);
 
+                    b.Navigation("Batch");
+
                     b.Navigation("Item");
 
                     b.Navigation("Return");
@@ -8248,6 +9943,25 @@ namespace ERPCore.Migrations
                     b.Navigation("SalesInvoiceLine");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesReturnLine", "ReturnLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("ReturnLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ReturnLine");
+
+                    b.Navigation("Serial");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.User", "CashierUser")
@@ -8323,15 +10037,66 @@ namespace ERPCore.Migrations
                     b.Navigation("Warehouse");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.SalesSlipLine", "SalesSlipLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("SalesSlipLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SalesSlipLine");
+
+                    b.Navigation("Serial");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Serial", b =>
                 {
+                    b.HasOne("ERPCore.Domain.Entities.Bin", "Bin")
+                        .WithMany()
+                        .HasForeignKey("BinId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.GrnLine", "GrnLine")
+                        .WithMany()
+                        .HasForeignKey("GrnLineId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
                     b.HasOne("ERPCore.Domain.Entities.Item", "Item")
                         .WithMany()
                         .HasForeignKey("ItemId")
                         .OnDelete(DeleteBehavior.Restrict)
                         .IsRequired();
 
+                    b.HasOne("ERPCore.Domain.Entities.Warehouse", "Warehouse")
+                        .WithMany()
+                        .HasForeignKey("WarehouseId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Bin");
+
+                    b.Navigation("GrnLine");
+
                     b.Navigation("Item");
+
+                    b.Navigation("Warehouse");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.SerialMovement", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
                 });
 
             modelBuilder.Entity("ERPCore.Domain.Entities.StageEdge", b =>
@@ -8470,7 +10235,7 @@ namespace ERPCore.Migrations
                         .OnDelete(DeleteBehavior.Restrict)
                         .IsRequired();
 
-                    b.HasOne("ERPCore.Domain.Entities.Serial", null)
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
                         .WithMany()
                         .HasForeignKey("SerialId")
                         .OnDelete(DeleteBehavior.Restrict);
@@ -8478,6 +10243,8 @@ namespace ERPCore.Migrations
                     b.Navigation("Adjustment");
 
                     b.Navigation("Item");
+
+                    b.Navigation("Serial");
                 });
 
             modelBuilder.Entity("ERPCore.Domain.Entities.StockCount", b =>
@@ -8695,6 +10462,30 @@ namespace ERPCore.Migrations
                     b.Navigation("Transfer");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLineSerial", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Batch", null)
+                        .WithMany()
+                        .HasForeignKey("BatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.StockTransferLine", "TransferLine")
+                        .WithMany("Serials")
+                        .HasForeignKey("TransferLineId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Serial");
+
+                    b.Navigation("TransferLine");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SubCategory", b =>
                 {
                     b.HasOne("ERPCore.Domain.Entities.Category", "Category")
@@ -8809,6 +10600,32 @@ namespace ERPCore.Migrations
                     b.Navigation("Branch");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.WarrantyRegistration", b =>
+                {
+                    b.HasOne("ERPCore.Domain.Entities.Customer", "Customer")
+                        .WithMany()
+                        .HasForeignKey("CustomerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Item", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ERPCore.Domain.Entities.Serial", "Serial")
+                        .WithMany()
+                        .HasForeignKey("SerialId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Customer");
+
+                    b.Navigation("Item");
+
+                    b.Navigation("Serial");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.BundleSale", b =>
                 {
                     b.Navigation("Lines");
@@ -8834,6 +10651,16 @@ namespace ERPCore.Migrations
                     b.Navigation("Lines");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.Expense", b =>
+                {
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("ERPCore.Domain.Entities.ExpenseCategory", b =>
+                {
+                    b.Navigation("Titles");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.Grn", b =>
                 {
                     b.Navigation("Lines");
@@ -8841,6 +10668,8 @@ namespace ERPCore.Migrations
 
             modelBuilder.Entity("ERPCore.Domain.Entities.GrnLine", b =>
                 {
+                    b.Navigation("Serials");
+
                     b.Navigation("WarrantyNumbers");
                 });
 
@@ -8874,6 +10703,11 @@ namespace ERPCore.Migrations
                     b.Navigation("Lines");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.PriceAdjustment", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.ProductionRun", b =>
                 {
                     b.Navigation("Edges");
@@ -8944,16 +10778,31 @@ namespace ERPCore.Migrations
                     b.Navigation("Payments");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesInvoiceLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturn", b =>
                 {
                     b.Navigation("Lines");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesReturnLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlip", b =>
                 {
                     b.Navigation("Lines");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.SalesSlipLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.StockAdjustment", b =>
                 {
                     b.Navigation("Lines");
@@ -8969,6 +10818,11 @@ namespace ERPCore.Migrations
                     b.Navigation("Lines");
                 });
 
+            modelBuilder.Entity("ERPCore.Domain.Entities.StockTransferLine", b =>
+                {
+                    b.Navigation("Serials");
+                });
+
             modelBuilder.Entity("ERPCore.Domain.Entities.SupportTicket", b =>
                 {
                     b.Navigation("Messages");
diff --git a/Backend/ERPCore/Program.cs b/Backend/ERPCore/Program.cs
index 5ab668c..9a74631 100644
--- a/Backend/ERPCore/Program.cs
+++ b/Backend/ERPCore/Program.cs
@@ -28,7 +28,7 @@ builder.Host.UseSerilog((ctx, cfg) => cfg
     .WriteTo.File("logs/erpcore-.log", rollingInterval: RollingInterval.Day));
 
 // Controllers + JSON: serialize enums as their string names (docs/11 §8, camelCase).
-builder.Services.AddControllers()
+builder.Services.AddControllers(o => o.Filters.Add<ERPCore.Infra.Filters.LowStockAlertFilter>())
     .AddJsonOptions(o => o.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));
 
 // EF Core + MariaDB (Pomelo). The server version is pinned explicitly rather than using
@@ -149,6 +149,19 @@ builder.Services.AddScoped<IGrnService, GrnService>();
 builder.Services.AddScoped<IPurchaseInvoiceService, PurchaseInvoiceService>();
 builder.Services.AddScoped<IPurchaseInvoicePaymentService, PurchaseInvoicePaymentService>();
 
+// Accounts: expenses (docs/EXPENSE_MODULE_PLAN.md). ExpenseService is also registered as itself:
+// ExpensePaymentService reuses its post step so Post & Pay is one transaction.
+builder.Services.AddScoped<IExpenseSetupService, ExpenseSetupService>();
+builder.Services.AddScoped<ExpenseService>();
+builder.Services.AddScoped<IExpenseService>(sp => sp.GetRequiredService<ExpenseService>());
+builder.Services.AddScoped<IExpensePaymentService, ExpensePaymentService>();
+
+// Accounts: bank deposits of till cash (docs/BANK_DEPOSIT_MODULE_PLAN.md). The business-day clock
+// is shared with the Day-End Sales Report so both agree on what "today" is.
+builder.Services.AddSingleton<BusinessDayClock>();
+builder.Services.AddScoped<ICashInHandService, CashInHandService>();
+builder.Services.AddScoped<IBankDepositService, BankDepositService>();
+
 // Sales (Phase 1)
 builder.Services.AddScoped<ISalesPricingService, SalesPricingService>();
 builder.Services.AddScoped<ISalesDomainService, SalesDomainService>();
@@ -163,14 +176,27 @@ builder.Services.AddScoped<ISalesPromotionSuggestionService, SalesPromotionSugge
 builder.Services.AddScoped<ISalesReportService, SalesReportService>();
 builder.Services.AddScoped<ISalesReturnService, SalesReturnService>();
 builder.Services.AddScoped<ISalesDayEndService, SalesDayEndService>();
+builder.Services.AddScoped<IDayEndReportService, DayEndReportService>();
 
 // Stock transactions + reference data (docs/11 §5–6)
 builder.Services.AddScoped<IStockMutator, StockMutator>();
+builder.Services.AddScoped<ISerialTrackingService, SerialTrackingService>();
+builder.Services.AddScoped<IItemTrackingService, ItemTrackingService>();
 builder.Services.AddScoped<IReasonCodeService, ReasonCodeService>();
-builder.Services.AddScoped<IAdjustmentService, AdjustmentService>();
+// AdjustmentService is also registered as itself: CountService submits its variances through it.
+builder.Services.AddScoped<AdjustmentService>();
+builder.Services.AddScoped<IAdjustmentService>(sp => sp.GetRequiredService<AdjustmentService>());
+builder.Services.AddScoped<IApprovalService, ApprovalService>();
+builder.Services.AddScoped<IPriceAdjustmentService, PriceAdjustmentService>();
+builder.Services.AddScoped<ApprovalInboxService>();
 builder.Services.AddScoped<ITransferService, TransferService>();
 builder.Services.AddScoped<ICountService, CountService>();
 builder.Services.AddScoped<IReorderService, ReorderService>();
+// Low-stock alerts: FIFO issues record into the tracker; the global LowStockAlertFilter checks
+// them against reorder points after each successful request and raises "stock.low".
+builder.Services.AddScoped<ERPCore.Services.Stock.LowStockTracker>();
+builder.Services.AddScoped<ERPCore.Services.Stock.LowStockAlertService>();
+builder.Services.AddScoped<ERPCore.Infra.Filters.LowStockAlertFilter>();
 builder.Services.AddScoped<IPurchaseReturnService, PurchaseReturnService>();
 
 // Cross-cutting: audit trail + GL-ready journal read access (docs/11 §6 / FR-X-02, FR-STK-13)
diff --git a/Backend/ERPCore/Services/AdjustmentService.cs b/Backend/ERPCore/Services/AdjustmentService.cs
index 0bda2f7..a7d5cd7 100644
--- a/Backend/ERPCore/Services/AdjustmentService.cs
+++ b/Backend/ERPCore/Services/AdjustmentService.cs
@@ -1,9 +1,11 @@
+using System.Text.Json;
 using ERPCore.Domain;
 using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Auth;
+using ERPCore.Infra.Persistence;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories.Interfaces;
 using ERPCore.Services.Gl;
@@ -15,54 +17,67 @@ using Microsoft.EntityFrameworkCore;
 namespace ERPCore.Services;
 
 /// <summary>
-/// Stock-adjustment service — the highest-risk feature (02-SECURITY C.5). Auto-posts
-/// with a mandatory reason code and user stamp. Line application (FIFO consume on a
-/// decrease, layer create on an increase) + ledger posting is delegated to
-/// <see cref="IStockMutator"/>. Runs in a single UoW transaction (NFR-02/05). Also posts
-/// a real GL journal entry — increases and decreases post as separate Inventory/Gain and
-/// Loss/Inventory lines respectively (never netted against each other), so a count that's
-/// simultaneously over on one item and under on another shows both, not a false net.
+/// Stock-adjustment service — the highest-risk feature (02-SECURITY C.5). An adjustment is a
+/// request with a mandatory reason code; it moves stock only once approved by one or two people
+/// other than the requester (docs/DUAL_APPROVAL_PLAN.md §5, rules in <see cref="IApprovalService"/>).
+/// With approvals switched off it posts on create, as it always used to. Posting — FIFO consume on a
+/// decrease, layer create on an increase, ledger, serial moves and the GL journal — is one
+/// transaction (NFR-02/05) and is re-validated at approval time, since stock and serials may have
+/// moved while the request waited. Increases and decreases post as separate Inventory/Gain and
+/// Loss/Inventory GL lines (never netted), so a count over on one item and under on another shows both.
 /// </summary>
 public sealed class AdjustmentService : IAdjustmentService
 {
+    public const string ApprovalDocType = "ADJ";
+    public const string ApprovalNavCode = "stock.adjustments";
+
+    private static readonly IReadOnlyCollection<SerialStatus> WriteOffStatuses = [SerialStatus.InStock, SerialStatus.Damaged];
+
     private readonly IRepository<StockAdjustment> _adjustments;
     private readonly IRepository<Warehouse> _warehouses;
     private readonly IRepository<Item> _items;
     private readonly IRepository<ReasonCode> _reasonCodes;
     private readonly IRepository<StockLedger> _ledger;
     private readonly IStockMutator _mutator;
+    private readonly IFifoCostingService _fifo;
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
     private readonly IBranchConfigService _branchConfig;
     private readonly INotificationService _notifications;
+    private readonly IApprovalService _approvals;
     private readonly IUnitOfWork _uow;
+    private readonly ErpDbContext _db;
+    private readonly ISerialTrackingService _serialTracking;
     private readonly IGeneralLedgerService _gl;
     private readonly IGlAccountConfigService _glAccounts;
 
     public AdjustmentService(
         IRepository<StockAdjustment> adjustments, IRepository<Warehouse> warehouses, IRepository<Item> items,
-        IRepository<ReasonCode> reasonCodes, IRepository<StockLedger> ledger, IStockMutator mutator,
-        INumberSequenceService numbers, ICurrentUser currentUser, IBranchConfigService branchConfig, INotificationService notifications, IUnitOfWork uow,
-        IGeneralLedgerService gl, IGlAccountConfigService glAccounts)
+        IRepository<ReasonCode> reasonCodes, IRepository<StockLedger> ledger, IStockMutator mutator, IFifoCostingService fifo,
+        INumberSequenceService numbers, ICurrentUser currentUser, IBranchConfigService branchConfig, INotificationService notifications,
+        IApprovalService approvals, IUnitOfWork uow, ErpDbContext db,
+        IGeneralLedgerService gl, IGlAccountConfigService glAccounts, ISerialTrackingService serialTracking)
     {
+        _serialTracking = serialTracking;
         _adjustments = adjustments;
         _warehouses = warehouses;
         _items = items;
         _reasonCodes = reasonCodes;
         _ledger = ledger;
         _mutator = mutator;
+        _fifo = fifo;
         _numbers = numbers;
         _currentUser = currentUser;
         _branchConfig = branchConfig;
         _notifications = notifications;
+        _approvals = approvals;
         _uow = uow;
+        _db = db;
         _gl = gl;
         _glAccounts = glAccounts;
     }
 
-    /// <summary>Builds and posts the GL journal for a <see cref="StockAdjustment"/>'s stock movement.
-    /// <see cref="CountService"/>'s variance posting mirrors this exact logic for the same reason
-    /// (it creates a <see cref="StockAdjustment"/> through the same <see cref="IStockMutator"/> call).</summary>
+    /// <summary>Builds and posts the GL journal for a <see cref="StockAdjustment"/>'s stock movement.</summary>
     private async Task<string?> PostAdjustmentJournalAsync(
         string docNo, DateTime now, IReadOnlyList<StockLedger> refs, CancellationToken ct)
     {
@@ -97,7 +112,7 @@ public sealed class AdjustmentService : IAdjustmentService
     }
 
     public async Task<PagedResponse<AdjustmentSummaryDto>> ListAsync(
-        PageQuery query, int? warehouseId, int? branchId, int? reasonCodeId, CancellationToken ct = default)
+        PageQuery query, int? warehouseId, int? branchId, int? reasonCodeId, AdjustmentStatus? status = null, CancellationToken ct = default)
     {
         var q = _adjustments.Query().AsNoTracking();
 
@@ -110,13 +125,15 @@ public sealed class AdjustmentService : IAdjustmentService
         // Warehouses are shared across branches — the adjustment carries its own owning BranchId.
         if (branchId is not null) q = q.Where(a => a.BranchId == branchId);
         if (reasonCodeId is not null) q = q.Where(a => a.ReasonCodeId == reasonCodeId);
+        if (status is not null) q = q.Where(a => a.Status == status);
 
         var total = await q.CountAsync(ct);
         var rows = await q.OrderByDescending(a => a.AdjustmentId)
             .Skip(query.Skip).Take(query.PageSize)
             .Select(a => new AdjustmentSummaryDto(
                 a.AdjustmentId, a.DocNo, a.WarehouseId, a.BranchId, a.ReasonCodeId, a.Status,
-                a.CreatedBy, a.CreatedAt, a.Lines.Count, a.GlJournalNo))
+                a.CreatedBy, a.CreatedAt, a.Lines.Count, a.GlJournalNo, a.RequiredApprovals,
+                a.Status == AdjustmentStatus.PendingApproval ? 1 : a.Status == AdjustmentStatus.PendingSecondApproval ? 2 : null))
             .ToListAsync(ct);
 
         return PagedResponse<AdjustmentSummaryDto>.Create(rows, query.Page, query.PageSize, total);
@@ -127,20 +144,22 @@ public sealed class AdjustmentService : IAdjustmentService
         var adjustment = await _adjustments.Query().AsNoTracking()
             .Include(a => a.Lines)
             .FirstOrDefaultAsync(a => a.AdjustmentId == adjustmentId, ct);
-        if (adjustment is null) return null;
-
-        // The ledger reference is polymorphic (docs/10 C.9) — there is no FK to follow,
-        // so the refs this adjustment posted are recovered by source-doc lookup.
-        var ledgerRefs = await _ledger.Query().AsNoTracking()
-            .Where(l => l.SourceDocType == DocumentTypes.Adjustment && l.SourceDocId == adjustmentId)
-            .OrderBy(l => l.LedgerId)
-            .Select(l => l.LedgerId)
-            .ToListAsync(ct);
-
-        return ToDto(adjustment, ledgerRefs);
+        return adjustment is null ? null : await ToDtoAsync(adjustment, ct);
     }
 
     public async Task<AdjustmentDto> CreateAsync(CreateAdjustmentRequest request, CancellationToken ct = default)
+    {
+        var (adjustment, refs) = await SubmitAsync(request, null, ct);
+        return await ToDtoAsync(adjustment, ct, refs.Select(l => l.LedgerId).ToList());
+    }
+
+    /// <summary>
+    /// Validates and saves an adjustment request; posts it straight away when no approval is
+    /// required. <paramref name="alsoInTransaction"/> lets a caller (a stock count) commit its own
+    /// change together with the adjustment. Returns the ledger entries posted (none while pending).
+    /// </summary>
+    internal async Task<(StockAdjustment Adjustment, IReadOnlyList<StockLedger> Refs)> SubmitAsync(
+        CreateAdjustmentRequest request, Func<CancellationToken, Task>? alsoInTransaction, CancellationToken ct)
     {
         if (request.ReasonCodeId is null)
             throw new DomainException(ErrorCodes.ReasonCodeRequired, "A reason code is required for an adjustment.", 400);
@@ -155,28 +174,34 @@ public sealed class AdjustmentService : IAdjustmentService
         if (reason.Context != ReasonContext.Adjustment)
             throw new DomainException(ErrorCodes.Validation, $"Reason code {request.ReasonCodeId} is not an Adjustment reason.", 422);
 
+        // Validate every line (and its serials) now, so a bad request is refused up front rather
+        // than at approval time. The value drives the approval threshold.
+        var value = 0m;
         foreach (var line in request.Lines)
         {
             if (line.QtyDelta == 0)
                 throw new DomainException(ErrorCodes.Validation, "qtyDelta cannot be zero.", 422);
-            if (!await _items.Query().AnyAsync(i => i.ItemId == line.ItemId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+            var item = await _items.Query().AsNoTracking().FirstOrDefaultAsync(i => i.ItemId == line.ItemId, ct)
+                ?? throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+            value += Math.Abs(line.QtyDelta) * await UnitValueAsync(line.ItemId, request.WarehouseId, ct);
         }
+        await ResolveSerialsAsync(request.WarehouseId, request.Lines.Select(ToPlan).ToList(), ct);
+        // Validated only: posting resolves them again and creates any new ones exactly once.
+        DiscardUnsavedSerials();
+
+        var required = await _approvals.RequiredForStockAdjustmentAsync(value, ct);
 
         var now = DateTime.UtcNow;
-        var deltas = request.Lines
-            .Select(l => new StockDelta(l.ItemId, l.BinId, l.BatchId, l.QtyDelta)).ToList();
-
-        var (adjustment, ledgerRefs) = await _uow.ExecuteInTransactionAsync(async token =>
+        var (adjustment, refs) = await _uow.ExecuteInTransactionAsync(async token =>
         {
-            var docNo = await _numbers.NextAsync(DocumentTypes.Adjustment, token);
             var entity = new StockAdjustment
             {
-                DocNo = docNo,
+                DocNo = await _numbers.NextAsync(DocumentTypes.Adjustment, token),
                 WarehouseId = request.WarehouseId,
                 BranchId = branchId,
                 ReasonCodeId = request.ReasonCodeId.Value,
-                Status = AdjustmentStatus.Posted,
+                Status = required == 0 ? AdjustmentStatus.Posted : AdjustmentStatus.PendingApproval,
+                RequiredApprovals = required,
                 CreatedBy = _currentUser.AuditUserId,
                 CreatedAt = now,
                 Lines = request.Lines.Select(l => new StockAdjustmentLine
@@ -184,29 +209,265 @@ public sealed class AdjustmentService : IAdjustmentService
                     ItemId = l.ItemId,
                     BinId = l.BinId,
                     BatchId = l.BatchId,
-                    QtyDelta = l.QtyDelta
+                    QtyDelta = l.QtyDelta,
+                    RequestedSerialIds = l.SerialIds is { Count: > 0 } ? JsonSerializer.Serialize(l.SerialIds) : null,
+                    RequestedSerialNos = l.SerialNos is { Count: > 0 } ? JsonSerializer.Serialize(l.SerialNos) : null
                 }).ToList()
             };
             await _adjustments.AddAsync(entity, token);
-            await _uow.SaveChangesAsync(token); // flush so AdjustmentId is a valid ledger sourceDocId
 
-            var refs = await _mutator.ApplyAsync(request.WarehouseId, DocumentTypes.Adjustment, entity.AdjustmentId, now, deltas, token);
-
-            entity.GlJournalNo = await PostAdjustmentJournalAsync(docNo, now, refs, token);
-            if (entity.GlJournalNo is not null) entity.GlPostedAt = now;
-
-            return (entity, refs);
+            IReadOnlyList<StockLedger> posted = [];
+            if (required == 0)
+            {
+                await _uow.SaveChangesAsync(token); // flush so AdjustmentId is a valid ledger sourceDocId
+                posted = await PostInCurrentTransactionAsync(entity, token);
+            }
+            if (alsoInTransaction is not null) await alsoInTransaction(token);
+            return (entity, posted);
         }, ct);
 
-        await _notifications.RaiseAsync("stock.adjustment.created", "Stock Adjustment Created", $"Stock adjustment {adjustment.DocNo} was created.", nameof(StockAdjustment), adjustment.AdjustmentId, ct);
-
-        return ToDto(adjustment, ledgerRefs.Select(l => l.LedgerId).ToList());
+        if (required == 0)
+        {
+            await _notifications.RaiseAsync("stock.adjustment.created", "Stock Adjustment Created", $"Stock adjustment {adjustment.DocNo} was created.", nameof(StockAdjustment), adjustment.AdjustmentId, ct);
+        }
+        else
+        {
+            await _approvals.NotifyPendingAsync(Target(adjustment), await SummaryAsync(adjustment, ct), ct);
+        }
+        return (adjustment, refs);
     }
 
-    private static AdjustmentDto ToDto(StockAdjustment a, IReadOnlyList<int> ledgerRefs) => new(
-        a.AdjustmentId, a.DocNo, a.WarehouseId, a.BranchId, a.ReasonCodeId, a.Status, a.CreatedBy, a.CreatedAt,
-        a.GlJournalNo, a.GlPostedAt,
-        a.Lines.OrderBy(l => l.AdjLineId)
-            .Select(l => new AdjustmentLineDto(l.AdjLineId, l.ItemId, l.BinId, l.BatchId, l.QtyDelta)).ToList(),
-        ledgerRefs);
+    public async Task<AdjustmentDto> ApproveAsync(int adjustmentId, string? comment, CancellationToken ct = default)
+    {
+        var adjustment = await LoadPendingAsync(adjustmentId, ct);
+        var target = Target(adjustment);
+        var now = DateTime.UtcNow;
+
+        var outcome = await _approvals.DecideAsync(target, approve: true, comment, ct);
+        IReadOnlyList<StockLedger> refs = [];
+        try
+        {
+            refs = await _uow.ExecuteInTransactionAsync(async token =>
+            {
+                if (target.CurrentLevel == 1)
+                {
+                    adjustment.ApprovedLevel1By = _currentUser.AuditUserId;
+                    adjustment.ApprovedLevel1At = now;
+                }
+                else
+                {
+                    adjustment.ApprovedLevel2By = _currentUser.AuditUserId;
+                    adjustment.ApprovedLevel2At = now;
+                }
+
+                if (outcome == ApprovalOutcome.AdvancedToLevel2)
+                {
+                    adjustment.Status = AdjustmentStatus.PendingSecondApproval;
+                    return (IReadOnlyList<StockLedger>)[];
+                }
+
+                adjustment.Status = AdjustmentStatus.Posted;
+                return await PostInCurrentTransactionAsync(adjustment, token);
+            }, ct);
+        }
+        catch (DbUpdateConcurrencyException)
+        {
+            throw new DomainException(ErrorCodes.ApprovalNotPending, $"Stock adjustment {adjustment.DocNo} was just decided by someone else — reload it.", 409);
+        }
+
+        if (outcome == ApprovalOutcome.AdvancedToLevel2)
+        {
+            await _approvals.NotifyPendingAsync(Target(adjustment), await SummaryAsync(adjustment, ct), ct);
+        }
+        else
+        {
+            await _notifications.NotifyUsersAsync([adjustment.CreatedBy], "approval.approved",
+                $"Approved: {adjustment.DocNo}", $"Stock adjustment {adjustment.DocNo} was approved and posted to stock.",
+                ApprovalDocType, adjustment.AdjustmentId, ct);
+            await _notifications.RaiseAsync("stock.adjustment.created", "Stock Adjustment Created", $"Stock adjustment {adjustment.DocNo} was posted.", nameof(StockAdjustment), adjustment.AdjustmentId, ct);
+        }
+
+        return await ToDtoAsync(adjustment, ct, refs.Select(r => r.LedgerId).ToList());
+    }
+
+    public async Task<AdjustmentDto> RejectAsync(int adjustmentId, string reason, CancellationToken ct = default)
+    {
+        var adjustment = await LoadPendingAsync(adjustmentId, ct);
+        await _approvals.DecideAsync(Target(adjustment), approve: false, reason, ct);
+
+        adjustment.Status = AdjustmentStatus.Rejected;
+        adjustment.RejectedBy = _currentUser.AuditUserId;
+        adjustment.RejectedAt = DateTime.UtcNow;
+        adjustment.RejectReason = reason.Trim();
+        await SaveDecisionAsync(adjustment, ct);
+
+        await _notifications.NotifyUsersAsync([adjustment.CreatedBy], "approval.rejected",
+            $"Rejected: {adjustment.DocNo}", $"Stock adjustment {adjustment.DocNo} was rejected: {adjustment.RejectReason}",
+            ApprovalDocType, adjustment.AdjustmentId, ct);
+        return await ToDtoAsync(adjustment, ct);
+    }
+
+    public async Task<AdjustmentDto> CancelAsync(int adjustmentId, CancellationToken ct = default)
+    {
+        var adjustment = await LoadPendingAsync(adjustmentId, ct);
+        if (adjustment.CreatedBy != _currentUser.AuditUserId)
+            throw new DomainException(ErrorCodes.ApprovalForbidden, "Only the person who made the request can withdraw it.", 403);
+
+        adjustment.Status = AdjustmentStatus.Cancelled;
+        adjustment.CancelledAt = DateTime.UtcNow;
+        await SaveDecisionAsync(adjustment, ct);
+        return await ToDtoAsync(adjustment, ct);
+    }
+
+    // --- Posting ---------------------------------------------------------------------------------
+
+    /// <summary>What a line asks for, from a request or from a saved pending line.</summary>
+    private sealed record LinePlan(int ItemId, int? BinId, int? BatchId, decimal QtyDelta, List<int>? SerialIds, List<string>? SerialNos);
+
+    private static LinePlan ToPlan(CreateAdjustmentLineInput l) => new(l.ItemId, l.BinId, l.BatchId, l.QtyDelta, l.SerialIds, l.SerialNos);
+
+    private static LinePlan ToPlan(StockAdjustmentLine l) => new(
+        l.ItemId, l.BinId, l.BatchId, l.QtyDelta,
+        l.RequestedSerialIds is null ? null : JsonSerializer.Deserialize<List<int>>(l.RequestedSerialIds),
+        l.RequestedSerialNos is null ? null : JsonSerializer.Deserialize<List<string>>(l.RequestedSerialNos));
+
+    /// <summary>
+    /// Outbound serials must be at the warehouse (InStock or Damaged); inbound numbers are new or
+    /// out of stock (new ones are added to the context, unsaved). Same rules on request and posting.
+    /// </summary>
+    private async Task<List<IReadOnlyList<Serial>>> ResolveSerialsAsync(int warehouseId, IReadOnlyList<LinePlan> lines, CancellationToken ct)
+    {
+        var result = new List<IReadOnlyList<Serial>>();
+        var documentSerials = new HashSet<int>();
+        var documentSerialNos = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var line in lines)
+        {
+            var item = await _items.Query().AsNoTracking().FirstAsync(i => i.ItemId == line.ItemId, ct);
+            result.Add(line.QtyDelta < 0
+                ? await _serialTracking.ResolveOutboundAsync(item, warehouseId, -line.QtyDelta, line.SerialIds, documentSerials, WriteOffStatuses, ct)
+                : await _serialTracking.ResolveInboundAsync(item, warehouseId, line.QtyDelta, line.SerialNos, documentSerialNos, ct));
+        }
+        return result;
+    }
+
+    /// <summary>Drops serials a pending request's validation added, so they aren't created early.</summary>
+    private void DiscardUnsavedSerials()
+    {
+        foreach (var entry in _db.ChangeTracker.Entries<Serial>().Where(e => e.State == EntityState.Added).ToList())
+            entry.State = EntityState.Detached;
+    }
+
+    /// <summary>
+    /// Applies a saved adjustment to stock: re-resolves its serials, FIFO-consumes / adds layers,
+    /// writes the ledger, moves serials and posts the GL journal. Runs inside the caller's transaction;
+    /// throws (rolling everything back) if stock or serials no longer allow it.
+    /// </summary>
+    private async Task<IReadOnlyList<StockLedger>> PostInCurrentTransactionAsync(StockAdjustment entity, CancellationToken ct)
+    {
+        var now = DateTime.UtcNow;
+        var lines = entity.Lines.OrderBy(l => l.AdjLineId).ToList();
+        var plans = lines.Select(ToPlan).ToList();
+        var serialsByLine = await ResolveSerialsAsync(entity.WarehouseId, plans, ct);
+        for (var i = 0; i < lines.Count; i++)
+            lines[i].Serial = serialsByLine[i].Count == 1 ? serialsByLine[i][0] : null;
+        await _uow.SaveChangesAsync(ct); // new serials get their ids
+
+        var deltas = plans.Select((l, i) => new StockDelta(l.ItemId, l.BinId, l.BatchId, l.QtyDelta,
+            serialsByLine[i].Select(s => s.SerialId).ToList())).ToList();
+        var refs = await _mutator.ApplyAsync(entity.WarehouseId, DocumentTypes.Adjustment, entity.AdjustmentId, now, deltas, ct);
+
+        for (var i = 0; i < plans.Count; i++)
+        {
+            var line = plans[i];
+            await _serialTracking.MoveAsync(serialsByLine[i],
+                line.QtyDelta < 0 ? SerialStatus.Scrapped : SerialStatus.InStock,
+                line.QtyDelta < 0 ? null : entity.WarehouseId, line.QtyDelta < 0 ? null : line.BinId,
+                DocumentTypes.Adjustment, entity.AdjustmentId, now, ct);
+        }
+
+        entity.GlJournalNo = await PostAdjustmentJournalAsync(entity.DocNo, now, refs, ct);
+        if (entity.GlJournalNo is not null) entity.GlPostedAt = now;
+        entity.PostedAt = now;
+        return refs;
+    }
+
+    // --- Helpers ---------------------------------------------------------------------------------
+
+    /// <summary>Average FIFO cost per unit at the warehouse — prices the request for the approval threshold.</summary>
+    private async Task<decimal> UnitValueAsync(int itemId, int warehouseId, CancellationToken ct)
+    {
+        var valuation = await _fifo.GetValuationAsync(itemId, warehouseId, ct);
+        return valuation.TotalQty > 0 ? valuation.TotalValue / valuation.TotalQty : 0m;
+    }
+
+    private async Task<StockAdjustment> LoadPendingAsync(int adjustmentId, CancellationToken ct)
+    {
+        var adjustment = await _adjustments.Query().Include(a => a.Lines)
+            .FirstOrDefaultAsync(a => a.AdjustmentId == adjustmentId, ct)
+            ?? throw new NotFoundException($"Stock adjustment {adjustmentId} was not found.");
+        if (adjustment.Status is not (AdjustmentStatus.PendingApproval or AdjustmentStatus.PendingSecondApproval))
+            throw new DomainException(ErrorCodes.ApprovalNotPending, $"Stock adjustment {adjustment.DocNo} is {adjustment.Status} and not waiting for approval.", 409);
+        return adjustment;
+    }
+
+    private async Task SaveDecisionAsync(StockAdjustment adjustment, CancellationToken ct)
+    {
+        try
+        {
+            await _uow.SaveChangesAsync(ct);
+        }
+        catch (DbUpdateConcurrencyException)
+        {
+            throw new DomainException(ErrorCodes.ApprovalNotPending, $"Stock adjustment {adjustment.DocNo} was just decided by someone else — reload it.", 409);
+        }
+    }
+
+    private static int? PendingLevel(StockAdjustment a) => a.Status switch
+    {
+        AdjustmentStatus.PendingApproval => 1,
+        AdjustmentStatus.PendingSecondApproval => 2,
+        _ => null
+    };
+
+    private static ApprovalTarget Target(StockAdjustment a) => new(
+        ApprovalDocType, a.AdjustmentId, a.DocNo, ApprovalNavCode, a.CreatedBy, a.RequiredApprovals,
+        PendingLevel(a) ?? 1, a.ApprovedLevel1By);
+
+    private async Task<string> SummaryAsync(StockAdjustment a, CancellationToken ct)
+    {
+        var warehouse = await _warehouses.Query().AsNoTracking().Where(w => w.WarehouseId == a.WarehouseId).Select(w => w.Code).FirstOrDefaultAsync(ct);
+        var reason = await _reasonCodes.Query().AsNoTracking().Where(r => r.ReasonCodeId == a.ReasonCodeId).Select(r => r.Description).FirstOrDefaultAsync(ct);
+        return $"Stock adjustment {a.DocNo} ({a.Lines.Count} line{(a.Lines.Count == 1 ? "" : "s")}, {warehouse}, {reason})";
+    }
+
+    private async Task<AdjustmentDto> ToDtoAsync(StockAdjustment a, CancellationToken ct, IReadOnlyList<int>? ledgerRefs = null)
+    {
+        // The ledger reference is polymorphic (docs/10 C.9) — there is no FK to follow,
+        // so the refs this adjustment posted are recovered by source-doc lookup.
+        ledgerRefs ??= await _ledger.Query().AsNoTracking()
+            .Where(l => l.SourceDocType == DocumentTypes.Adjustment && l.SourceDocId == a.AdjustmentId)
+            .OrderBy(l => l.LedgerId)
+            .Select(l => l.LedgerId)
+            .ToListAsync(ct);
+
+        var pending = PendingLevel(a);
+        var whyNot = pending is null ? "Not waiting for approval." : await _approvals.WhyCannotDecideAsync(Target(a), ct);
+
+        return new AdjustmentDto(
+            a.AdjustmentId, a.DocNo, a.WarehouseId, a.BranchId, a.ReasonCodeId, a.Status, a.CreatedBy, a.CreatedAt,
+            a.GlJournalNo, a.GlPostedAt,
+            a.Lines.OrderBy(l => l.AdjLineId).Select(l =>
+            {
+                var plan = ToPlan(l);
+                return new AdjustmentLineDto(l.AdjLineId, l.ItemId, l.BinId, l.BatchId, l.QtyDelta, l.SerialId, plan.SerialIds, plan.SerialNos);
+            }).ToList(),
+            ledgerRefs,
+            a.RequiredApprovals, pending,
+            a.ApprovedLevel1By, a.ApprovedLevel1At, a.ApprovedLevel2By, a.ApprovedLevel2At,
+            a.RejectedBy, a.RejectedAt, a.RejectReason, a.PostedAt,
+            await _approvals.HistoryAsync(ApprovalDocType, a.AdjustmentId, ct),
+            whyNot is null, whyNot,
+            pending is not null && a.CreatedBy == _currentUser.AuditUserId,
+            await _db.Users.AsNoTracking().Where(u => u.UserId == a.CreatedBy).Select(u => u.DisplayName).FirstOrDefaultAsync(ct));
+    }
 }
diff --git a/Backend/ERPCore/Services/ApprovalInboxService.cs b/Backend/ERPCore/Services/ApprovalInboxService.cs
new file mode 100644
index 0000000..89884ff
--- /dev/null
+++ b/Backend/ERPCore/Services/ApprovalInboxService.cs
@@ -0,0 +1,93 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Approvals;
+using ERPCore.Infra.Auth;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// The Approvals inbox (docs/DUAL_APPROVAL_PLAN.md §10): every pending stock and price adjustment
+/// the current user can approve, plus their own requests (shown as waiting for others). A branch
+/// user only sees their branch's stock adjustments; price changes are company-wide.
+/// </summary>
+public sealed class ApprovalInboxService
+{
+    private readonly IRepository<StockAdjustment> _stock;
+    private readonly IRepository<PriceAdjustment> _prices;
+    private readonly IApprovalService _approvals;
+    private readonly INavPermissionService _nav;
+    private readonly ICurrentUser _currentUser;
+    private readonly ICurrentBranchContext _branch;
+
+    public ApprovalInboxService(
+        IRepository<StockAdjustment> stock, IRepository<PriceAdjustment> prices, IApprovalService approvals,
+        INavPermissionService nav, ICurrentUser currentUser, ICurrentBranchContext branch)
+    {
+        _stock = stock;
+        _prices = prices;
+        _approvals = approvals;
+        _nav = nav;
+        _currentUser = currentUser;
+        _branch = branch;
+    }
+
+    public async Task<PendingApprovalsDto> PendingAsync(CancellationToken ct = default)
+    {
+        var me = _currentUser.AuditUserId;
+        var canStock = await CanApproveScreenAsync(AdjustmentService.ApprovalNavCode, ct);
+        var canPrice = await CanApproveScreenAsync(PriceAdjustmentService.ApprovalNavCode, ct);
+        var items = new List<PendingApprovalDto>();
+
+        var stockQuery = _stock.Query().AsNoTracking()
+            .Where(a => a.Status == AdjustmentStatus.PendingApproval || a.Status == AdjustmentStatus.PendingSecondApproval)
+            .Where(a => canStock || a.CreatedBy == me);
+        if (_branch.IsActive) stockQuery = stockQuery.Where(a => a.BranchId == _branch.BranchId);
+        var stock = await stockQuery
+            .Select(a => new
+            {
+                a.AdjustmentId, a.DocNo, a.Status, a.RequiredApprovals, a.CreatedBy, a.CreatedAt, a.ApprovedLevel1By,
+                RequestedByName = a.Creator!.DisplayName, Warehouse = a.Warehouse!.Code, Reason = a.ReasonCode!.Description, Lines = a.Lines.Count
+            })
+            .ToListAsync(ct);
+        foreach (var a in stock)
+        {
+            var level = a.Status == AdjustmentStatus.PendingApproval ? 1 : 2;
+            var target = new ApprovalTarget(AdjustmentService.ApprovalDocType, a.AdjustmentId, a.DocNo, AdjustmentService.ApprovalNavCode,
+                a.CreatedBy, a.RequiredApprovals, level, a.ApprovedLevel1By);
+            var why = canStock ? await _approvals.WhyCannotDecideAsync(target, ct) : "Waiting for an approver.";
+            items.Add(new PendingApprovalDto(AdjustmentService.ApprovalDocType, a.AdjustmentId, a.DocNo,
+                $"Stock adjustment — {a.Lines} line{(a.Lines == 1 ? "" : "s")}, {a.Warehouse}, {a.Reason}",
+                level, a.RequiredApprovals, a.CreatedBy, a.RequestedByName, a.CreatedAt, why is null, why));
+        }
+
+        var prices = await _prices.Query().AsNoTracking()
+            .Where(p => p.Status == PriceAdjustmentStatus.PendingApproval || p.Status == PriceAdjustmentStatus.PendingSecondApproval)
+            .Where(p => canPrice || p.CreatedBy == me)
+            .Select(p => new
+            {
+                p.PriceAdjustmentId, p.DocNo, p.Status, p.RequiredApprovals, p.CreatedBy, p.CreatedAt, p.ApprovedLevel1By,
+                RequestedByName = p.Creator!.DisplayName, p.Reason, Lines = p.Lines.Count
+            })
+            .ToListAsync(ct);
+        foreach (var p in prices)
+        {
+            var level = p.Status == PriceAdjustmentStatus.PendingApproval ? 1 : 2;
+            var target = new ApprovalTarget(PriceAdjustmentService.ApprovalDocType, p.PriceAdjustmentId, p.DocNo, PriceAdjustmentService.ApprovalNavCode,
+                p.CreatedBy, p.RequiredApprovals, level, p.ApprovedLevel1By);
+            var why = canPrice ? await _approvals.WhyCannotDecideAsync(target, ct) : "Waiting for an approver.";
+            items.Add(new PendingApprovalDto(PriceAdjustmentService.ApprovalDocType, p.PriceAdjustmentId, p.DocNo,
+                $"Price adjustment — {p.Lines} item{(p.Lines == 1 ? "" : "s")}: {p.Reason}",
+                level, p.RequiredApprovals, p.CreatedBy, p.RequestedByName, p.CreatedAt, why is null, why));
+        }
+
+        // Actionable first, then oldest first — the longest-waiting request is what needs attention.
+        var ordered = items.OrderByDescending(i => i.CanApprove).ThenBy(i => i.RequestedAt).ToList();
+        return new PendingApprovalsDto(ordered, ordered.Count(i => i.CanApprove));
+    }
+
+    private async Task<bool> CanApproveScreenAsync(string navCode, CancellationToken ct)
+        => _currentUser.IsAdmin || await _nav.HasActionAsync(_currentUser.RoleCode, navCode, RolePermissionAction.Approve, ct);
+}
diff --git a/Backend/ERPCore/Services/ApprovalService.cs b/Backend/ERPCore/Services/ApprovalService.cs
new file mode 100644
index 0000000..de121c1
--- /dev/null
+++ b/Backend/ERPCore/Services/ApprovalService.cs
@@ -0,0 +1,178 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Approvals;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Shared approval engine for stock and price adjustments (docs/DUAL_APPROVAL_PLAN.md §4). Holds the
+/// maker–checker rules in one place; the document services call <see cref="DecideAsync"/> and apply
+/// their effect only on <see cref="ApprovalOutcome.FullyApproved"/>. There is no Admin bypass of the
+/// two-person rule — an Admin can approve, but never their own request and never both levels.
+/// </summary>
+public sealed class ApprovalService : IApprovalService
+{
+    private const string AdminRoleCode = "Admin";
+
+    private readonly IRepository<ApprovalConfig> _config;
+    private readonly IRepository<DocumentApproval> _approvals;
+    private readonly IRepository<User> _users;
+    private readonly IRepository<RolePermission> _rolePermissions;
+    private readonly ICurrentUser _currentUser;
+    private readonly INotificationService _notifications;
+    private readonly IUnitOfWork _uow;
+
+    public ApprovalService(
+        IRepository<ApprovalConfig> config, IRepository<DocumentApproval> approvals, IRepository<User> users,
+        IRepository<RolePermission> rolePermissions, ICurrentUser currentUser, INotificationService notifications, IUnitOfWork uow)
+    {
+        _config = config;
+        _approvals = approvals;
+        _users = users;
+        _rolePermissions = rolePermissions;
+        _currentUser = currentUser;
+        _notifications = notifications;
+        _uow = uow;
+    }
+
+    public async Task<ApprovalConfigDto> GetConfigAsync(CancellationToken ct = default) => Map(await LoadConfigAsync(ct));
+
+    public async Task<ApprovalConfigDto> UpdateConfigAsync(UpdateApprovalConfigRequest request, CancellationToken ct = default)
+    {
+        var config = await _config.Query().FirstOrDefaultAsync(c => c.ApprovalConfigId == ApprovalConfig.SingletonId, ct);
+        if (config is null)
+        {
+            config = new ApprovalConfig { ApprovalConfigId = ApprovalConfig.SingletonId };
+            await _config.AddAsync(config, ct);
+        }
+
+        config.StockAdjustmentLevels = Math.Clamp(request.StockAdjustmentLevels, 0, 2);
+        config.StockAdjustmentLevel2ThresholdValue = Math.Max(0m, request.StockAdjustmentLevel2ThresholdValue);
+        config.PriceAdjustmentLevels = Math.Clamp(request.PriceAdjustmentLevels, 0, 2);
+        config.PriceAdjustmentLevel2ThresholdPercent = Math.Max(0m, request.PriceAdjustmentLevel2ThresholdPercent);
+        var roles = request.Level2RoleCodes.Select(r => r.Trim()).Where(r => r.Length > 0).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
+        config.Level2RoleCodes = roles.Count == 0 ? null : string.Join(",", roles);
+        config.UpdatedAt = DateTime.UtcNow;
+        config.UpdatedBy = _currentUser.AuditUserId;
+
+        await _uow.SaveChangesAsync(ct);
+        return Map(config);
+    }
+
+    public async Task<int> RequiredForStockAdjustmentAsync(decimal absoluteValue, CancellationToken ct = default)
+    {
+        var c = await LoadConfigAsync(ct);
+        return Levels(c.StockAdjustmentLevels, c.StockAdjustmentLevel2ThresholdValue, absoluteValue);
+    }
+
+    public async Task<int> RequiredForPriceAdjustmentAsync(decimal largestChangePercent, CancellationToken ct = default)
+    {
+        var c = await LoadConfigAsync(ct);
+        return Levels(c.PriceAdjustmentLevels, c.PriceAdjustmentLevel2ThresholdPercent, largestChangePercent);
+    }
+
+    /// <summary>Two levels drop to one below a positive threshold; 0 and 1 are taken as configured.</summary>
+    public static int Levels(int configured, decimal threshold, decimal measure)
+        => configured >= 2 && threshold > 0 && measure < threshold ? 1 : Math.Clamp(configured, 0, 2);
+
+    public async Task<ApprovalOutcome> DecideAsync(ApprovalTarget target, bool approve, string? comment, CancellationToken ct = default)
+    {
+        var (why, code) = await CheckAsync(target, ct);
+        if (why is not null) throw new DomainException(code!, why, 403);
+
+        var note = string.IsNullOrWhiteSpace(comment) ? null : comment.Trim();
+        if (!approve && note is null)
+            throw new DomainException(ErrorCodes.ApprovalReasonRequired, "Give a reason for rejecting.", 400);
+
+        await _approvals.AddAsync(new DocumentApproval
+        {
+            DocType = target.DocType,
+            DocId = target.DocId,
+            Level = target.CurrentLevel,
+            Decision = approve ? ApprovalDecision.Approved : ApprovalDecision.Rejected,
+            DecidedBy = _currentUser.AuditUserId,
+            DecidedAt = DateTime.UtcNow,
+            Comment = note
+        }, ct);
+
+        if (!approve) return ApprovalOutcome.Rejected;
+        return target.CurrentLevel >= target.RequiredApprovals ? ApprovalOutcome.FullyApproved : ApprovalOutcome.AdvancedToLevel2;
+    }
+
+    public async Task<string?> WhyCannotDecideAsync(ApprovalTarget target, CancellationToken ct = default)
+        => (await CheckAsync(target, ct)).Why;
+
+    private async Task<(string? Why, string? Code)> CheckAsync(ApprovalTarget target, CancellationToken ct)
+    {
+        var actor = _currentUser.AuditUserId;
+        if (actor == target.RequestedBy)
+            return ("You made this request — someone else has to approve it.", ErrorCodes.ApprovalForbidden);
+        if (target.CurrentLevel >= 2 && target.Level1ApprovedBy == actor)
+            return ("You gave the first approval — a different person has to give the second.", ErrorCodes.ApprovalSamePerson);
+        if (target.CurrentLevel >= 2)
+        {
+            var roles = Level2Roles(await LoadConfigAsync(ct));
+            if (roles.Count > 0 && !_currentUser.IsAdmin && !roles.Contains(_currentUser.RoleCode ?? string.Empty))
+                return ($"Only {string.Join(", ", roles)} can give the second approval.", ErrorCodes.ApprovalRoleRequired);
+        }
+        return (null, null);
+    }
+
+    public async Task<IReadOnlyList<ApprovalStepDto>> HistoryAsync(string docType, int docId, CancellationToken ct = default)
+        => await _approvals.Query().AsNoTracking()
+            .Where(a => a.DocType == docType && a.DocId == docId)
+            .OrderBy(a => a.DocumentApprovalId)
+            .Select(a => new ApprovalStepDto(a.Level, a.Decision, a.DecidedBy, a.Decider!.DisplayName, a.DecidedAt, a.Comment))
+            .ToListAsync(ct);
+
+    public async Task<IReadOnlyList<int>> ApproverIdsAsync(ApprovalTarget target, CancellationToken ct = default)
+    {
+        var permissionCode = "NAV:" + target.NavCode;
+        var grants = await _rolePermissions.Query().AsNoTracking()
+            .Where(rp => rp.Permission!.Code == permissionCode)
+            .Select(rp => new { rp.RoleId, rp.Actions })
+            .ToListAsync(ct);
+        var approverRoleIds = grants.Where(g => g.Actions.HasFlag(RolePermissionAction.Approve)).Select(g => g.RoleId).ToHashSet();
+
+        var candidates = await _users.Query().AsNoTracking()
+            .Where(u => u.Status == EntityStatus.Active && u.RoleId != null)
+            .Select(u => new { u.UserId, RoleId = u.RoleId!.Value, RoleCode = u.Role!.Code })
+            .ToListAsync(ct);
+
+        var level2Roles = target.CurrentLevel >= 2 ? Level2Roles(await LoadConfigAsync(ct)) : [];
+        return candidates
+            .Where(u => string.Equals(u.RoleCode, AdminRoleCode, StringComparison.OrdinalIgnoreCase) || approverRoleIds.Contains(u.RoleId))
+            .Where(u => u.UserId != target.RequestedBy && u.UserId != target.Level1ApprovedBy)
+            .Where(u => level2Roles.Count == 0 || level2Roles.Contains(u.RoleCode) || string.Equals(u.RoleCode, AdminRoleCode, StringComparison.OrdinalIgnoreCase))
+            .Select(u => u.UserId)
+            .ToList();
+    }
+
+    public async Task NotifyPendingAsync(ApprovalTarget target, string summary, CancellationToken ct = default)
+    {
+        var approvers = await ApproverIdsAsync(target, ct);
+        var step = target.RequiredApprovals > 1 ? $" (approval {target.CurrentLevel} of {target.RequiredApprovals})" : string.Empty;
+        await _notifications.NotifyUsersAsync(approvers, "approval.pending",
+            $"Approval needed: {target.DocNo}", $"{summary} is waiting for your approval{step}.", target.DocType, target.DocId, ct);
+    }
+
+    private async Task<ApprovalConfig> LoadConfigAsync(CancellationToken ct)
+        => await _config.Query().AsNoTracking().FirstOrDefaultAsync(c => c.ApprovalConfigId == ApprovalConfig.SingletonId, ct)
+           ?? new ApprovalConfig { ApprovalConfigId = ApprovalConfig.SingletonId };
+
+    private static HashSet<string> Level2Roles(ApprovalConfig c)
+        => (c.Level2RoleCodes ?? string.Empty)
+            .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+    private static ApprovalConfigDto Map(ApprovalConfig c) => new(
+        c.StockAdjustmentLevels, c.StockAdjustmentLevel2ThresholdValue,
+        c.PriceAdjustmentLevels, c.PriceAdjustmentLevel2ThresholdPercent,
+        Level2Roles(c).ToList(), c.UpdatedAt);
+}
diff --git a/Backend/ERPCore/Services/BankDepositService.cs b/Backend/ERPCore/Services/BankDepositService.cs
new file mode 100644
index 0000000..73a75ad
--- /dev/null
+++ b/Backend/ERPCore/Services/BankDepositService.cs
@@ -0,0 +1,283 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Accounts;
+using ERPCore.Dtos.Common;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.Persistence;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Gl;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Till cash taken to the bank (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.2). Saving a deposit posts a
+/// real GL entry (Debit the bank account / Credit the cash account) before anything is committed —
+/// the same call-GL-before-commit pattern as <see cref="ExpensePaymentService"/>, so a GL rejection
+/// rolls the deposit back. A deposit may not exceed the branch's cash in hand
+/// (<see cref="ICashInHandService"/>); the check runs inside the transaction after locking the
+/// branch row, so two cashiers can't both deposit the same cash. Cancelling posts the reversing entry.
+/// </summary>
+public sealed class BankDepositService : IBankDepositService
+{
+    private const string SourceModule = "BANK_DEPOSIT";
+
+    private readonly IRepository<BankDeposit> _deposits;
+    private readonly IRepository<Branch> _branches;
+    private readonly ICashInHandService _cash;
+    private readonly IGeneralLedgerService _gl;
+    private readonly ICurrentUser _currentUser;
+    private readonly ICurrentBranchContext _currentBranch;
+    private readonly INumberSequenceService _numbers;
+    private readonly IBranchConfigService _branchConfig;
+    private readonly IUnitOfWork _uow;
+    private readonly ErpDbContext _db;
+    private readonly BusinessDayClock _clock;
+
+    public BankDepositService(
+        IRepository<BankDeposit> deposits, IRepository<Branch> branches, ICashInHandService cash,
+        IGeneralLedgerService gl, ICurrentUser currentUser, ICurrentBranchContext currentBranch,
+        INumberSequenceService numbers, IBranchConfigService branchConfig, IUnitOfWork uow,
+        ErpDbContext db, BusinessDayClock clock)
+    {
+        _deposits = deposits;
+        _branches = branches;
+        _cash = cash;
+        _gl = gl;
+        _currentUser = currentUser;
+        _currentBranch = currentBranch;
+        _numbers = numbers;
+        _branchConfig = branchConfig;
+        _uow = uow;
+        _db = db;
+        _clock = clock;
+    }
+
+    public async Task<BankDepositListDto> ListAsync(PageQuery query, BankDepositListFilter filter, CancellationToken ct = default)
+    {
+        IQueryable<BankDeposit> q = _deposits.Query().AsNoTracking().Include(x => x.Branch);
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(x => EF.Functions.Like(x.DocNo, $"%{term}%")
+                || (x.DepositSlipNo != null && EF.Functions.Like(x.DepositSlipNo, $"%{term}%"))
+                || (x.DepositedBy != null && EF.Functions.Like(x.DepositedBy, $"%{term}%")));
+        }
+        if (filter.From is not null) q = q.Where(x => x.BusinessDate >= filter.From);
+        if (filter.To is not null) q = q.Where(x => x.BusinessDate <= filter.To);
+        if (filter.BranchId is not null) q = q.Where(x => x.BranchId == filter.BranchId);
+        if (filter.BankAccountId is not null) q = q.Where(x => x.ToGlBankAccountId == filter.BankAccountId);
+        if (filter.Status is not null) q = q.Where(x => x.Status == filter.Status);
+
+        var total = await q.CountAsync(ct);
+        var totalAmount = await q.SumAsync(x => x.Amount, ct);
+        var rows = await q.OrderByDescending(x => x.BusinessDate).ThenByDescending(x => x.BankDepositId)
+            .Skip(query.Skip).Take(query.PageSize).ToListAsync(ct);
+
+        var page = PagedResponse<BankDepositDto>.Create(rows.Select(Map).ToList(), query.Page, query.PageSize, total);
+        return new BankDepositListDto(page.Items, page.Pagination, totalAmount);
+    }
+
+    public async Task<BankDepositDto?> GetAsync(int bankDepositId, CancellationToken ct = default)
+    {
+        var deposit = await _deposits.Query().AsNoTracking().Include(x => x.Branch)
+            .FirstOrDefaultAsync(x => x.BankDepositId == bankDepositId, ct);
+        return deposit is null ? null : Map(deposit);
+    }
+
+    public async Task<BankDepositDto> CreateAsync(CreateBankDepositRequest request, CancellationToken ct = default)
+    {
+        if (request.Amount <= 0)
+            throw new DomainException(ErrorCodes.Validation, "The deposit amount must be greater than zero.", 400);
+
+        var (branchId, cashScope) = await ResolveBranchAsync(request.BranchId, ct);
+        var branch = await _branches.Query().AsNoTracking().FirstOrDefaultAsync(b => b.BranchId == branchId, ct)
+            ?? throw new DomainException(ErrorCodes.Validation, $"Branch {branchId} does not exist.", 422);
+
+        var depositDate = ValidateDates(request);
+        var (cashAccount, bankAccount) = await ResolveAccountsAsync(request, ct);
+
+        var deposit = await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            await LockBranchAsync(branchId, token);
+
+            // Re-read inside the lock: a deposit committed a moment ago by someone else is now visible.
+            var available = await _cash.GetAvailableToDepositAsync(request.BusinessDate, cashScope, token);
+            if (request.Amount > available)
+                throw new DomainException(ErrorCodes.BankDepositExceedsCashInHand,
+                    $"Amount {request.Amount:N2} exceeds the cash in hand available for {request.BusinessDate:yyyy-MM-dd} ({available:N2}).", 400);
+
+            var docNo = await _numbers.NextAsync(DocumentTypes.BankDeposit, branchId, token);
+            var narration = $"Cash deposit {docNo} — {request.BusinessDate:yyyy-MM-dd}";
+            var period = await _gl.GetPeriodByDateAsync(depositDate, token);
+            var posted = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+            {
+                PeriodId = period.PeriodId,
+                EntryDate = depositDate,
+                SourceModule = SourceModule,
+                Reference = docNo,
+                Narration = narration,
+                Lines =
+                [
+                    new GlJournalEntryLineRequest(bankAccount.GlAccountCode, request.Amount, 0m, narration),
+                    new GlJournalEntryLineRequest(cashAccount.GlAccountCode, 0m, request.Amount, narration)
+                ]
+            }, token);
+
+            var now = DateTime.UtcNow;
+            var entity = new BankDeposit
+            {
+                DocNo = docNo,
+                BranchId = branchId,
+                BusinessDate = request.BusinessDate,
+                DepositDate = depositDate,
+                Amount = request.Amount,
+                FromGlCashAccountId = cashAccount.AccountId,
+                FromCashAccountCode = cashAccount.GlAccountCode,
+                FromCashAccountName = cashAccount.AccountName,
+                ToGlBankAccountId = bankAccount.AccountId,
+                ToBankAccountCode = bankAccount.GlAccountCode,
+                ToBankAccountName = bankAccount.AccountName,
+                ToBankName = bankAccount.BankName,
+                ToAccountNumber = bankAccount.AccountNumber,
+                DepositSlipNo = Normalize(request.DepositSlipNo),
+                DepositedBy = Normalize(request.DepositedBy),
+                Remarks = Normalize(request.Remarks),
+                Status = BankDepositStatus.Posted,
+                GlJournalNo = posted.JournalNo,
+                GlPostedAt = now,
+                CreatedBy = _currentUser.AuditUserId,
+                CreatedAt = now
+            };
+            await _deposits.AddAsync(entity, token);
+            return entity;
+        }, ct);
+
+        return Map(deposit, branch.Name);
+    }
+
+    public async Task<BankDepositDto> CancelAsync(int bankDepositId, CancelBankDepositRequest request, CancellationToken ct = default)
+    {
+        var deposit = await _deposits.Query().Include(x => x.Branch)
+            .FirstOrDefaultAsync(x => x.BankDepositId == bankDepositId, ct)
+            ?? throw new NotFoundException($"Bank deposit {bankDepositId} was not found.");
+
+        if (deposit.Status != BankDepositStatus.Posted)
+            throw new DomainException(ErrorCodes.BankDepositNotCancellable, $"Bank deposit {deposit.DocNo} is already {deposit.Status}.", 409);
+
+        // Cancelling only puts cash back in hand, so there is no balance to check.
+        var now = DateTime.UtcNow;
+        await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            var today = _clock.Today;
+            var narration = $"Cancellation of cash deposit {deposit.DocNo}";
+            var period = await _gl.GetPeriodByDateAsync(today, token);
+            var reversal = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+            {
+                PeriodId = period.PeriodId,
+                EntryDate = today,
+                SourceModule = SourceModule,
+                Reference = deposit.DocNo,
+                Narration = narration,
+                Lines =
+                [
+                    new GlJournalEntryLineRequest(deposit.FromCashAccountCode, deposit.Amount, 0m, narration),
+                    new GlJournalEntryLineRequest(deposit.ToBankAccountCode, 0m, deposit.Amount, narration)
+                ]
+            }, token);
+
+            deposit.Status = BankDepositStatus.Cancelled;
+            deposit.GlReversalJournalNo = reversal.JournalNo;
+            deposit.CancelReason = request.Reason.Trim();
+            deposit.CancelledBy = _currentUser.AuditUserId;
+            deposit.CancelledAt = now;
+            return 0;
+        }, ct);
+
+        return Map(deposit);
+    }
+
+    /// <summary>
+    /// The branch the deposit belongs to and the branch scope its cash in hand is measured over. A
+    /// branch user always deposits for their own branch. With branching off every document lives on
+    /// the one default branch, so the cash is measured across all of them (scope null).
+    /// </summary>
+    private async Task<(int BranchId, int? CashScope)> ResolveBranchAsync(int requested, CancellationToken ct)
+    {
+        if (_currentBranch.IsActive && _currentBranch.BranchId is { } own)
+            return (own, own);
+
+        var branchId = await _branchConfig.ResolveBranchIdAsync(requested, ct);
+        return await _branchConfig.IsBranchingEnabledAsync(ct) ? (branchId, branchId) : (branchId, null);
+    }
+
+    private DateOnly ValidateDates(CreateBankDepositRequest request)
+    {
+        var today = _clock.Today;
+        if (request.BusinessDate > today)
+            throw new DomainException(ErrorCodes.BankDepositDateInvalid, "The business date cannot be in the future.", 400);
+        if (_cash.TrackingStartDate is { } start && request.BusinessDate < start)
+            throw new DomainException(ErrorCodes.BankDepositDateInvalid,
+                $"Cash in hand is tracked from {start:yyyy-MM-dd}; earlier days cannot be deposited.", 400);
+
+        var depositDate = request.DepositDate ?? request.BusinessDate;
+        if (depositDate < request.BusinessDate)
+            throw new DomainException(ErrorCodes.BankDepositDateInvalid, "The deposit date cannot be before the business date.", 400);
+        // One day of slack, as with payment dates: the client sends its local date.
+        if (depositDate > today.AddDays(1))
+            throw new DomainException(ErrorCodes.BankDepositDateInvalid, "The deposit date cannot be in the future.", 400);
+        return depositDate;
+    }
+
+    private async Task<(GlBankAccount Cash, GlBankAccount Bank)> ResolveAccountsAsync(CreateBankDepositRequest request, CancellationToken ct)
+    {
+        var accounts = await _gl.ListBankAccountsAsync(ct);
+
+        // GL keeps cash and bank accounts in separate tables with their own ids, so cash account 1 and
+        // bank account 1 can both exist — an id only means something together with its type.
+        var cash = accounts.FirstOrDefault(a => a.AccountId == request.FromGlCashAccountId && IsType(a, "Cash"))
+            ?? throw new DomainException(ErrorCodes.BankDepositCashAccountInvalid,
+                $"Cash account {request.FromGlCashAccountId} was not found — deposits must come out of a cash account.", 400);
+
+        var bank = accounts.FirstOrDefault(a => a.AccountId == request.ToGlBankAccountId && IsType(a, "Bank"));
+        if (bank is null)
+            throw new DomainException(ErrorCodes.BankDepositBankAccountInvalid,
+                $"Bank account {request.ToGlBankAccountId} was not found — deposits must go into a bank account.", 400);
+
+        return (cash, bank);
+    }
+
+    private static bool IsType(GlBankAccount account, string type)
+        => string.Equals(account.AccountType, type, StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Serializes deposits per branch for the rest of the transaction: the second of two concurrent
+    /// deposits waits here, then sees the first one's committed row when it re-reads the balance.
+    /// The in-memory test provider has no row locks (or concurrency), so it is skipped there.
+    /// </summary>
+    private async Task LockBranchAsync(int branchId, CancellationToken ct)
+    {
+        if (!_db.Database.IsRelational()) return;
+        await _db.Database.ExecuteSqlInterpolatedAsync(
+            $"SELECT `BranchId` FROM `hr_branches` WHERE `BranchId` = {branchId} FOR UPDATE", ct);
+    }
+
+    private static string? Normalize(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+
+    /// <summary><paramref name="branchName"/> stands in when the Branch navigation isn't loaded (just created).</summary>
+    private static BankDepositDto Map(BankDeposit x) => Map(x, x.Branch?.Name);
+
+    private static BankDepositDto Map(BankDeposit x, string? branchName) => new(
+        x.BankDepositId, x.DocNo, x.BranchId, branchName,
+        x.BusinessDate, x.DepositDate, x.Amount,
+        x.FromGlCashAccountId, x.FromCashAccountCode, x.FromCashAccountName,
+        x.ToGlBankAccountId, x.ToBankAccountCode, x.ToBankAccountName, x.ToBankName, x.ToAccountNumber,
+        x.DepositSlipNo, x.DepositedBy, x.Remarks,
+        x.Status, x.GlJournalNo, x.GlPostedAt,
+        x.GlReversalJournalNo, x.CancelReason, x.CancelledAt,
+        x.CreatedBy, x.CreatedAt);
+}
diff --git a/Backend/ERPCore/Services/BundleSaleService.cs b/Backend/ERPCore/Services/BundleSaleService.cs
index 9be21f1..5731ae4 100644
--- a/Backend/ERPCore/Services/BundleSaleService.cs
+++ b/Backend/ERPCore/Services/BundleSaleService.cs
@@ -178,7 +178,7 @@ public sealed class BundleSaleService : IBundleSaleService
         };
         bundle.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
         bundle.Lines = await BuildLinesAsync(template, request.WarehouseId, request.Lines, ct);
-        Recalculate(bundle, request.BundlePrice);
+        Recalculate(bundle, request.BundlePrice, request.CardAmount);
         bundle.BundleCode = $"{bundle.BundleNo}-B";
         await _bundles.AddAsync(bundle, ct);
         await _uow.SaveChangesAsync(ct);
@@ -203,7 +203,7 @@ public sealed class BundleSaleService : IBundleSaleService
         bundle.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
         bundle.Lines.Clear();
         foreach (var line in await BuildLinesAsync(template, request.WarehouseId, request.Lines, ct)) bundle.Lines.Add(line);
-        Recalculate(bundle, request.BundlePrice);
+        Recalculate(bundle, request.BundlePrice, request.CardAmount);
         bundle.UpdatedAt = DateTime.UtcNow;
         await _uow.SaveChangesAsync(ct);
         return Map(bundle);
@@ -273,7 +273,8 @@ public sealed class BundleSaleService : IBundleSaleService
         return lines;
     }
 
-    private static void Recalculate(BundleSale bundle, decimal bundlePrice)
+    /// <summary>A bundle sale is always fully paid; <paramref name="cardAmount"/> null means all cash.</summary>
+    private static void Recalculate(BundleSale bundle, decimal bundlePrice, decimal? cardAmount)
     {
         bundle.ComponentSubtotal = bundle.Lines.Where(x => x.IncludeInBundle).Sum(x => x.LineTotal);
         bundle.BundlePrice = bundlePrice;
@@ -281,6 +282,13 @@ public sealed class BundleSaleService : IBundleSaleService
         bundle.DiscountTotal = Math.Max(0m, bundle.ComponentSubtotal - bundle.BundlePrice);
         bundle.TaxTotal = 0m;
         bundle.GrandTotal = bundle.BundlePrice + bundle.TaxTotal;
+
+        var card = cardAmount ?? 0m;
+        if (card < 0 || card > bundle.GrandTotal)
+            throw new DomainException(ErrorCodes.SalesCardAmountInvalid,
+                $"cardAmount must be between 0 and the bundle's total {bundle.GrandTotal}.", 400);
+        bundle.CardAmount = card;
+        bundle.CashAmount = bundle.GrandTotal - card;
     }
 
     private static BundleSaleSummaryDto MapSummary(BundleSale x) => new(
@@ -290,6 +298,7 @@ public sealed class BundleSaleService : IBundleSaleService
         x.BundleSaleId, x.BundleNo, x.BundleDate, x.CustomerId, x.CustomerSnapshotName, x.WarehouseId, x.CashierUserId, x.BundleSaleTemplateId,
         x.BundleName, x.BundleCode, x.Status, x.ComponentSubtotal, x.BundlePrice, x.MarginAmount, x.DiscountTotal, x.TaxTotal, x.GrandTotal,
         x.CreatedAt, x.UpdatedAt,
-        x.Lines.Select(l => new BundleSaleLineDto(l.BundleSaleLineId, l.ItemId, l.Description, l.Qty, l.WarehouseId, l.UnitPrice, l.LineTotal, l.IncludeInBundle, l.IsComponent, l.ParentLineId)).ToList());
+        x.Lines.Select(l => new BundleSaleLineDto(l.BundleSaleLineId, l.ItemId, l.Description, l.Qty, l.WarehouseId, l.UnitPrice, l.LineTotal, l.IncludeInBundle, l.IsComponent, l.ParentLineId)).ToList(),
+        x.CashAmount, x.CardAmount);
 
 }
diff --git a/Backend/ERPCore/Services/BusinessDayClock.cs b/Backend/ERPCore/Services/BusinessDayClock.cs
new file mode 100644
index 0000000..d8dec1b
--- /dev/null
+++ b/Backend/ERPCore/Services/BusinessDayClock.cs
@@ -0,0 +1,34 @@
+namespace ERPCore.Services;
+
+/// <summary>
+/// The business calendar day shared by the Day-End Sales Report and the Bank Deposit module
+/// (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.1). Sales documents are stamped in UTC, so a business day
+/// is the <c>DayEndReport:TimeZone</c> calendar day converted to a UTC <c>[start, end)</c> window.
+/// One instance per app — the zone is resolved once from configuration.
+/// </summary>
+public sealed class BusinessDayClock
+{
+    public BusinessDayClock(IConfiguration configuration)
+        => Zone = ResolveZone(configuration["DayEndReport:TimeZone"]);
+
+    public TimeZoneInfo Zone { get; }
+
+    /// <summary>Today in the business time zone.</summary>
+    public DateOnly Today => LocalDay(DateTime.UtcNow);
+
+    /// <summary>The UTC instant the local day starts at.</summary>
+    public DateTime ToUtc(DateOnly localDay)
+        => TimeZoneInfo.ConvertTimeToUtc(localDay.ToDateTime(TimeOnly.MinValue, DateTimeKind.Unspecified), Zone);
+
+    /// <summary>The local business day a UTC timestamp falls on.</summary>
+    public DateOnly LocalDay(DateTime utc)
+        => DateOnly.FromDateTime(TimeZoneInfo.ConvertTimeFromUtc(DateTime.SpecifyKind(utc, DateTimeKind.Utc), Zone));
+
+    private static TimeZoneInfo ResolveZone(string? id)
+    {
+        if (string.IsNullOrWhiteSpace(id)) return TimeZoneInfo.Utc;
+        try { return TimeZoneInfo.FindSystemTimeZoneById(id); }
+        catch (TimeZoneNotFoundException) { return TimeZoneInfo.Utc; }
+        catch (InvalidTimeZoneException) { return TimeZoneInfo.Utc; }
+    }
+}
diff --git a/Backend/ERPCore/Services/CashInHandService.cs b/Backend/ERPCore/Services/CashInHandService.cs
new file mode 100644
index 0000000..98698ee
--- /dev/null
+++ b/Backend/ERPCore/Services/CashInHandService.cs
@@ -0,0 +1,196 @@
+using System.Globalization;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Accounts;
+using ERPCore.Infra.Auth;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Till cash in hand (docs/BANK_DEPOSIT_MODULE_PLAN.md §2, §7.1). Only cash counts: slip and bundle
+/// <c>CashAmount</c> and cash invoice payments come in, cash expense payments go out, and Posted bank
+/// deposits take it to the bank. The balance carries from day to day starting at
+/// <c>BankDeposit:CashTrackingStartDate</c>; the opening balance before a window is a handful of
+/// database sums, and the days inside it are bucketed by local day here (same reason as
+/// <see cref="DayEndReportService"/>: MariaDB can't portably group by a zone-shifted date).
+/// </summary>
+public sealed class CashInHandService : ICashInHandService
+{
+    private const int MaxRangeDays = 92;
+
+    private readonly IRepository<SalesSlip> _slips;
+    private readonly IRepository<BundleSale> _bundles;
+    private readonly IRepository<SalesInvoicePayment> _invoicePayments;
+    private readonly IRepository<ExpensePayment> _expensePayments;
+    private readonly IRepository<BankDeposit> _deposits;
+    private readonly ICurrentBranchContext _currentBranch;
+    private readonly BusinessDayClock _clock;
+    private readonly string? _defaultCashAccountCode;
+
+    public CashInHandService(
+        IRepository<SalesSlip> slips, IRepository<BundleSale> bundles, IRepository<SalesInvoicePayment> invoicePayments,
+        IRepository<ExpensePayment> expensePayments, IRepository<BankDeposit> deposits,
+        ICurrentBranchContext currentBranch, BusinessDayClock clock, IConfiguration configuration)
+    {
+        _slips = slips;
+        _bundles = bundles;
+        _invoicePayments = invoicePayments;
+        _expensePayments = expensePayments;
+        _deposits = deposits;
+        _currentBranch = currentBranch;
+        _clock = clock;
+        _defaultCashAccountCode = configuration["BankDeposit:DefaultCashAccountCode"];
+        TrackingStartDate = DateOnly.TryParse(configuration["BankDeposit:CashTrackingStartDate"], CultureInfo.InvariantCulture, out var start)
+            ? start
+            : null;
+    }
+
+    public DateOnly? TrackingStartDate { get; }
+
+    public async Task<CashInHandDto> GetPositionAsync(DateOnly? day, int? branchId, CancellationToken ct = default)
+    {
+        var date = day ?? _clock.Today;
+        var branch = EffectiveBranch(branchId);
+        var today = _clock.Today;
+
+        // One pass from the day to today serves both the day's own figures and what is still depositable.
+        var days = await ComputeAsync(date, date > today ? date : today, branch, ct);
+        return new CashInHandDto(days[0], Available(days, date, today), branch, TrackingStartDate, _clock.Zone.Id, _defaultCashAccountCode);
+    }
+
+    public async Task<CashInHandDailyDto> GetDailyAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct = default)
+    {
+        if (to < from)
+            throw new DomainException(ErrorCodes.DayEndReportRangeInvalid, "'to' must be on or after 'from'.", 400);
+        if (to.DayNumber - from.DayNumber + 1 > MaxRangeDays)
+            throw new DomainException(ErrorCodes.DayEndReportRangeInvalid, $"The range can be at most {MaxRangeDays} days.", 400);
+
+        var branch = EffectiveBranch(branchId);
+        var days = await ComputeAsync(from, to, branch, ct);
+        return new CashInHandDailyDto(from, to, days, branch, TrackingStartDate, _clock.Zone.Id);
+    }
+
+    public async Task<IReadOnlyList<CashPositionDto>> GetRangeAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct = default)
+        => await ComputeAsync(from, to, EffectiveBranch(branchId), ct);
+
+    public async Task<decimal> GetAvailableToDepositAsync(DateOnly day, int? branchScope, CancellationToken ct = default)
+    {
+        var today = _clock.Today;
+        if (day > today || !IsTracked(day)) return 0m;
+        return Available(await ComputeAsync(day, today, branchScope, ct), day, today);
+    }
+
+    /// <summary>A branch-scoped (non-admin) caller always sees only their own branch, whatever they ask for.</summary>
+    private int? EffectiveBranch(int? requested) => _currentBranch.IsActive ? _currentBranch.BranchId : requested;
+
+    private bool IsTracked(DateOnly day) => TrackingStartDate is not { } start || day >= start;
+
+    /// <summary>Lowest closing balance from <paramref name="day"/> to today: depositing more would overdraw a later day.</summary>
+    private decimal Available(IReadOnlyList<CashPositionDto> days, DateOnly day, DateOnly today)
+    {
+        if (day > today || !IsTracked(day)) return 0m;
+        var min = days.Where(d => d.Date >= day && d.Date <= today).Min(d => d.Closing);
+        return Math.Max(0m, min);
+    }
+
+    private async Task<List<CashPositionDto>> ComputeAsync(DateOnly from, DateOnly to, int? branch, CancellationToken ct)
+    {
+        // Opening: everything tracked before the window — [start, from).
+        var opening = 0m;
+        if (TrackingStartDate is not { } trackStart || trackStart < from)
+        {
+            DateTime? lo = TrackingStartDate is { } s ? _clock.ToUtc(s) : null;
+            var hi = _clock.ToUtc(from);
+            var cashIn = await Slips(lo, hi, branch).SumAsync(s => s.CashAmount, ct)
+                + await Bundles(lo, hi, branch).SumAsync(b => b.CashAmount, ct)
+                + await InvoicePayments(lo, hi, branch).SumAsync(p => p.Amount, ct);
+            var cashOut = await ExpensePayments(lo, hi, branch).SumAsync(p => p.Amount, ct);
+            var deposited = await Deposits(TrackingStartDate, from, branch).SumAsync(d => d.Amount, ct);
+            opening = cashIn - cashOut - deposited;
+        }
+
+        // The window itself, bucketed by local day.
+        var start = _clock.ToUtc(from);
+        var end = _clock.ToUtc(to.AddDays(1));
+        var inRows = new List<(DateTime At, decimal Amount)>();
+        inRows.AddRange((await Slips(start, end, branch).Select(s => new { s.SlipDate, s.CashAmount }).ToListAsync(ct))
+            .Select(r => (r.SlipDate, r.CashAmount)));
+        inRows.AddRange((await Bundles(start, end, branch).Select(b => new { b.BundleDate, b.CashAmount }).ToListAsync(ct))
+            .Select(r => (r.BundleDate, r.CashAmount)));
+        inRows.AddRange((await InvoicePayments(start, end, branch).Select(p => new { p.PaymentDate, p.Amount }).ToListAsync(ct))
+            .Select(r => (r.PaymentDate, r.Amount)));
+        var outRows = await ExpensePayments(start, end, branch).Select(p => new { p.PaymentDate, p.Amount }).ToListAsync(ct);
+        var depositRows = await Deposits(from, to.AddDays(1), branch).Select(d => new { d.BusinessDate, d.Amount }).ToListAsync(ct);
+
+        var inByDay = inRows.GroupBy(r => _clock.LocalDay(r.At)).ToDictionary(g => g.Key, g => g.Sum(r => r.Amount));
+        var outByDay = outRows.GroupBy(r => _clock.LocalDay(r.PaymentDate)).ToDictionary(g => g.Key, g => g.Sum(r => r.Amount));
+        var depositByDay = depositRows.GroupBy(r => r.BusinessDate).ToDictionary(g => g.Key, g => g.Sum(r => r.Amount));
+
+        var days = new List<CashPositionDto>(to.DayNumber - from.DayNumber + 1);
+        var running = opening;
+        for (var day = from; day <= to; day = day.AddDays(1))
+        {
+            var cashIn = inByDay.GetValueOrDefault(day);
+            var cashOut = outByDay.GetValueOrDefault(day);
+            var deposited = depositByDay.GetValueOrDefault(day);
+            var net = cashIn - cashOut;
+
+            // Before tracking starts nothing carries in or out; the day stands alone.
+            var tracked = IsTracked(day);
+            var open = tracked ? running : 0m;
+            var close = open + net - deposited;
+            if (tracked) running = close;
+
+            days.Add(new CashPositionDto(day, open, cashIn, cashOut, net, deposited, close));
+        }
+        return days;
+    }
+
+    // --- Sources. lo is inclusive (null = no lower bound), hi exclusive. ---
+
+    private IQueryable<SalesSlip> Slips(DateTime? lo, DateTime hi, int? branch)
+    {
+        var q = _slips.Query().AsNoTracking()
+            .Where(s => s.Status == SalesSlipStatus.Posted && s.CashAmount != 0 && s.SlipDate < hi);
+        if (lo is not null) q = q.Where(s => s.SlipDate >= lo);
+        return branch is null ? q : q.Where(s => s.Warehouse!.BranchId == branch);
+    }
+
+    private IQueryable<BundleSale> Bundles(DateTime? lo, DateTime hi, int? branch)
+    {
+        var q = _bundles.Query().AsNoTracking()
+            .Where(b => b.Status == BundleSaleStatus.Posted && b.CashAmount != 0 && b.BundleDate < hi);
+        if (lo is not null) q = q.Where(b => b.BundleDate >= lo);
+        return branch is null ? q : q.Where(b => b.Warehouse!.BranchId == branch);
+    }
+
+    /// <summary>Cash received against Posted invoices — whatever day the invoice itself is from.</summary>
+    private IQueryable<SalesInvoicePayment> InvoicePayments(DateTime? lo, DateTime hi, int? branch)
+    {
+        var q = _invoicePayments.Query().AsNoTracking()
+            .Where(p => p.PaymentMethod == SalesPaymentMethod.Cash && p.SalesInvoice!.Status == SalesInvoiceStatus.Posted && p.PaymentDate < hi);
+        if (lo is not null) q = q.Where(p => p.PaymentDate >= lo);
+        return branch is null ? q : q.Where(p => p.SalesInvoice!.BranchId == branch);
+    }
+
+    private IQueryable<ExpensePayment> ExpensePayments(DateTime? lo, DateTime hi, int? branch)
+    {
+        var q = _expensePayments.Query().AsNoTracking()
+            .Where(p => p.PaymentMethod == ExpensePaymentMethod.Cash && p.Expense!.Status != ExpenseStatus.Cancelled && p.PaymentDate < hi);
+        if (lo is not null) q = q.Where(p => p.PaymentDate >= lo);
+        return branch is null ? q : q.Where(p => p.Expense!.BranchId == branch);
+    }
+
+    /// <summary>Posted deposits by business date; <paramref name="lo"/> inclusive (null = no bound), <paramref name="hi"/> exclusive.</summary>
+    private IQueryable<BankDeposit> Deposits(DateOnly? lo, DateOnly hi, int? branch)
+    {
+        var q = _deposits.Query().AsNoTracking()
+            .Where(d => d.Status == BankDepositStatus.Posted && d.BusinessDate < hi);
+        if (lo is not null) q = q.Where(d => d.BusinessDate >= lo);
+        return branch is null ? q : q.Where(d => d.BranchId == branch);
+    }
+}
diff --git a/Backend/ERPCore/Services/CountService.cs b/Backend/ERPCore/Services/CountService.cs
index 0f68255..7ff851d 100644
--- a/Backend/ERPCore/Services/CountService.cs
+++ b/Backend/ERPCore/Services/CountService.cs
@@ -16,91 +16,52 @@ namespace ERPCore.Services;
 
 /// <summary>
 /// Stock-count service (FR-STK-08). Create snapshots system quantities (immutable,
-/// 02-SECURITY C.7); posting emits a variance <see cref="StockAdjustment"/> via the
-/// shared <see cref="IStockMutator"/> (a variance is an adjustment in disguise, C.7)
-/// and closes the count — all in one UoW transaction. GL posting for that variance
-/// mirrors <see cref="AdjustmentService"/>'s (same account config, same gain/loss
-/// split) since it's the exact same kind of document under the hood.
+/// 02-SECURITY C.7); posting closes the count and hands its variances to
+/// <see cref="AdjustmentService"/> as one adjustment (a variance is an adjustment in disguise,
+/// C.7). That adjustment follows the same approval rules as any other
+/// (docs/DUAL_APPROVAL_PLAN.md §8, decision 3) — a count is not a way around approval — and
+/// moves stock when it is approved, or at once when approvals are switched off.
 /// </summary>
 public sealed class CountService : ICountService
 {
     private const string VarianceReasonCode = "VAR";
 
     private readonly IRepository<StockCount> _counts;
-    private readonly IRepository<StockAdjustment> _adjustments;
     private readonly IRepository<Warehouse> _warehouses;
     private readonly IRepository<Item> _items;
     private readonly IRepository<ReasonCode> _reasonCodes;
     private readonly IFifoCostingService _fifo;
-    private readonly IStockMutator _mutator;
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
     private readonly IBranchConfigService _branchConfig;
     private readonly IUnitOfWork _uow;
-    private readonly IGeneralLedgerService _gl;
     private readonly IRepository<StockLayer> _stockLayers;
     private readonly IRepository<Batch> _batches;
     private readonly IRepository<Serial> _serials;
-    private readonly IGlAccountConfigService _glAccounts;
+    private readonly ISerialTrackingService _serialTracking;
+    private readonly AdjustmentService _adjustments;
 
     public CountService(
-        IRepository<StockCount> counts, IRepository<StockAdjustment> adjustments, IRepository<Warehouse> warehouses,
-        IRepository<Item> items, IRepository<ReasonCode> reasonCodes, IFifoCostingService fifo, IStockMutator mutator,
+        IRepository<StockCount> counts, IRepository<Warehouse> warehouses,
+        IRepository<Item> items, IRepository<ReasonCode> reasonCodes, IFifoCostingService fifo,
         INumberSequenceService numbers, ICurrentUser currentUser, IBranchConfigService branchConfig, IUnitOfWork uow,
-        IGeneralLedgerService gl, IRepository<StockLayer> stockLayers, IRepository<Batch> batches,
-        IRepository<Serial> serials, IGlAccountConfigService glAccounts)
+        IRepository<StockLayer> stockLayers, IRepository<Batch> batches,
+        IRepository<Serial> serials, ISerialTrackingService serialTracking, AdjustmentService adjustments)
     {
+        _serialTracking = serialTracking;
         _counts = counts;
-        _adjustments = adjustments;
         _warehouses = warehouses;
         _items = items;
         _reasonCodes = reasonCodes;
         _fifo = fifo;
-        _mutator = mutator;
         _numbers = numbers;
         _currentUser = currentUser;
         _branchConfig = branchConfig;
         _uow = uow;
-        _gl = gl;
         _stockLayers = stockLayers;
         _batches = batches;
         _serials = serials;
-        _glAccounts = glAccounts;
-    }
-
-    /// <summary>Same logic as <c>AdjustmentService</c>'s private method of the same name — see there for why
-    /// gains/losses post as separate lines instead of a net.</summary>
-    private async Task<string?> PostAdjustmentJournalAsync(
-        string docNo, DateTime now, IReadOnlyList<StockLedger> refs, CancellationToken ct)
-    {
-        var gain = refs.Where(r => r.Direction == Direction.In).Sum(r => r.Value);
-        var loss = refs.Where(r => r.Direction == Direction.Out).Sum(r => r.Value);
-        if (gain <= 0 && loss <= 0) return null;
-
-        var glCodes = await _glAccounts.GetCodesAsync(ct);
-        var period = await _gl.GetPeriodByDateAsync(BusinessClock.ToBusinessDate(now), ct);
-        var lines = new List<GlJournalEntryLineRequest>();
-        if (gain > 0)
-        {
-            lines.Add(new GlJournalEntryLineRequest(glCodes[GlAccountRole.Inventory], gain, 0m, $"Adjustment {docNo} — stock increase"));
-            lines.Add(new GlJournalEntryLineRequest(glCodes[GlAccountRole.InventoryGain], 0m, gain, $"Adjustment {docNo} — inventory gain"));
-        }
-        if (loss > 0)
-        {
-            lines.Add(new GlJournalEntryLineRequest(glCodes[GlAccountRole.InventoryLoss], loss, 0m, $"Adjustment {docNo} — inventory loss"));
-            lines.Add(new GlJournalEntryLineRequest(glCodes[GlAccountRole.Inventory], 0m, loss, $"Adjustment {docNo} — stock decrease"));
-        }
-
-        var result = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
-        {
-            PeriodId = period.PeriodId,
-            EntryDate = BusinessClock.ToBusinessDate(now),
-            SourceModule = "ADJUSTMENT",
-            Reference = docNo,
-            Narration = $"Stock adjustment {docNo}",
-            Lines = lines
-        }, ct);
-        return result.JournalNo;
+        _adjustments = adjustments;
     }
 
     public async Task<PagedResponse<CountSummaryDto>> ListAsync(
@@ -171,17 +132,32 @@ public sealed class CountService : ICountService
                         .SumAsync(l => (decimal?)l.QtyRemaining, ct) ?? 0m;
                     lines.Add(new StockCountLine { ItemId = id, BatchId = batch.BatchId, SystemQty = systemQty });
                 }
+                // Stock that reached the item without a batch (e.g. an adjustment) is counted on its own line.
+                var unbatched = await _stockLayers.Query().AsNoTracking()
+                    .Where(l => l.ItemId == id && l.WarehouseId == request.WarehouseId && l.BatchId == null)
+                    .SumAsync(l => (decimal?)l.QtyRemaining, ct) ?? 0m;
+                if (unbatched != 0)
+                    lines.Add(new StockCountLine { ItemId = id, BatchId = null, SystemQty = unbatched });
             }
-            else if (item.TrackingMode == TrackingMode.Serial)
+            else if (await _serialTracking.IsSerialTrackedAsync(item, ct)) // off: counted as one aggregate line
             {
+                // Serials that should be at this warehouse (one line each, counted 0 or 1), plus
+                // one aggregate line for any pre-tracking serial-less stock still here (D6).
                 var serials = await _serials.Query().AsNoTracking()
-                    .Where(s => s.ItemId == id && s.Status == "InStock").ToListAsync(ct);
+                    .Where(s => s.ItemId == id && s.WarehouseId == request.WarehouseId
+                        && (s.Status == SerialStatus.InStock || s.Status == SerialStatus.Damaged))
+                    .OrderBy(s => s.SerialNo).ToListAsync(ct);
                 foreach (var serial in serials)
                 {
                     var open = await _stockLayers.Query().AsNoTracking().AnyAsync(
                         l => l.ItemId == id && l.WarehouseId == request.WarehouseId && l.SerialId == serial.SerialId && l.QtyRemaining > 0, ct);
                     lines.Add(new StockCountLine { ItemId = id, SerialId = serial.SerialId, SystemQty = open ? 1 : 0 });
                 }
+                var untracked = await _stockLayers.Query().AsNoTracking()
+                    .Where(l => l.ItemId == id && l.WarehouseId == request.WarehouseId && l.SerialId == null)
+                    .SumAsync(l => (decimal?)l.QtyRemaining, ct) ?? 0m;
+                if (untracked != 0 || serials.Count == 0)
+                    lines.Add(new StockCountLine { ItemId = id, SystemQty = untracked });
             }
             else
             {
@@ -225,6 +201,8 @@ public sealed class CountService : ICountService
         {
             var line = count.Lines.FirstOrDefault(l => l.CountLineId == input.CountLineId)
                 ?? throw new DomainException(ErrorCodes.Validation, $"Count line {input.CountLineId} is not on count {countId}.", 422);
+            if (line.SerialId is not null && input.CountedQty is not (0m or 1m))
+                throw new DomainException(ErrorCodes.Validation, $"Count line {input.CountLineId} is one serial — count it as 0 or 1.", 422);
             line.CountedQty = input.CountedQty;
             line.Variance = input.CountedQty - line.SystemQty;
         }
@@ -246,13 +224,11 @@ public sealed class CountService : ICountService
         if (count.Status != CountStatus.Counted)
             throw new ConflictException($"Count {countId} has no entered counts to post.");
 
-        var deltas = count.Lines
-            .Where(l => l.Variance.HasValue && l.Variance.Value != 0)
-            .Select(l => new StockDelta(l.ItemId, l.BinId, null, l.Variance!.Value))
-            .ToList();
+        // Batch and serial lines adjust exactly their own lot/unit.
+        var varianceLines = count.Lines.Where(l => l.Variance.HasValue && l.Variance.Value != 0).ToList();
 
         // No variances → just close the count, no adjustment.
-        if (deltas.Count == 0)
+        if (varianceLines.Count == 0)
         {
             count.Status = CountStatus.Posted;
             await _uow.SaveChangesAsync(ct);
@@ -263,40 +239,33 @@ public sealed class CountService : ICountService
             .FirstOrDefaultAsync(r => r.Context == ReasonContext.Adjustment && r.Code == VarianceReasonCode, ct)
             ?? throw new DomainException(ErrorCodes.Validation, $"Reason code '{VarianceReasonCode}' (Count Variance) is not configured.", 422);
 
-        var now = DateTime.UtcNow;
-        var (adjustmentId, glJournalNo, ledgerEntries) = await _uow.ExecuteInTransactionAsync(async token =>
+        // A serial counted missing is written off (Scrapped); one found is brought back InStock —
+        // the adjustment's own serial rules, applied when it posts.
+        var request = new CreateAdjustmentRequest
         {
-            var docNo = await _numbers.NextAsync(DocumentTypes.Adjustment, token);
-            var adjustment = new StockAdjustment
+            WarehouseId = count.WarehouseId,
+            BranchId = count.BranchId,
+            ReasonCodeId = reason.ReasonCodeId,
+            Lines = varianceLines.Select(l => new CreateAdjustmentLineInput
             {
-                DocNo = docNo,
-                WarehouseId = count.WarehouseId,
-                BranchId = count.BranchId,
-                ReasonCodeId = reason.ReasonCodeId,
-                Status = AdjustmentStatus.Posted,
-                CreatedBy = _currentUser.AuditUserId,
-                CreatedAt = now,
-                Lines = deltas.Select(d => new StockAdjustmentLine
-                {
-                    ItemId = d.ItemId,
-                    BinId = d.BinId,
-                    QtyDelta = d.QtyDelta
-                }).ToList()
-            };
-            await _adjustments.AddAsync(adjustment, token);
-            await _uow.SaveChangesAsync(token); // flush for a valid ledger sourceDocId
-
-            var refs = await _mutator.ApplyAsync(count.WarehouseId, DocumentTypes.Adjustment, adjustment.AdjustmentId, now, deltas, token);
-
-            adjustment.GlJournalNo = await PostAdjustmentJournalAsync(docNo, now, refs, token);
-            if (adjustment.GlJournalNo is not null) adjustment.GlPostedAt = now;
+                ItemId = l.ItemId,
+                BinId = l.BinId,
+                BatchId = l.BatchId,
+                QtyDelta = l.Variance!.Value,
+                SerialIds = l.SerialId is int missing && l.Variance < 0 ? [missing] : null,
+                SerialNos = l.Serial is not null && l.Variance > 0 ? [l.Serial.SerialNo] : null
+            }).ToList()
+        };
 
+        var (adjustment, refs) = await _adjustments.SubmitAsync(request, _ =>
+        {
             count.Status = CountStatus.Posted;
-            return (adjustment.AdjustmentId, adjustment.GlJournalNo, refs);
+            return Task.CompletedTask;
         }, ct);
 
-        // Map ledger ids after commit so they are populated.
-        return new CountPostResultDto(count.CountId, count.Status, adjustmentId, glJournalNo, ledgerEntries.Select(r => r.LedgerId).ToList());
+        return new CountPostResultDto(
+            count.CountId, count.Status, adjustment.AdjustmentId, adjustment.GlJournalNo, refs.Select(r => r.LedgerId).ToList(),
+            adjustment.Status, adjustment.DocNo);
     }
 
     private static CountDto Map(StockCount c) => new(
diff --git a/Backend/ERPCore/Services/CustomerService.cs b/Backend/ERPCore/Services/CustomerService.cs
index fc7b112..35931c9 100644
--- a/Backend/ERPCore/Services/CustomerService.cs
+++ b/Backend/ERPCore/Services/CustomerService.cs
@@ -17,6 +17,8 @@ public sealed class CustomerService : ICustomerService
     private readonly IRepository<Warehouse> _warehouses;
     private readonly IBranchConfigService _branchConfig;
     private readonly IRepository<SalesConfig> _salesConfig;
+    private readonly IRepository<SalesInvoice> _invoices;
+    private readonly IRepository<SalesInvoicePayment> _invoicePayments;
     private readonly IUnitOfWork _uow;
 
     /// <summary>Code of the system "Cash Customer" row (see <see cref="SalesConfigService"/>).</summary>
@@ -24,12 +26,15 @@ public sealed class CustomerService : ICustomerService
 
     public CustomerService(
         IRepository<Customer> customers, IRepository<Warehouse> warehouses, IBranchConfigService branchConfig,
-        IRepository<SalesConfig> salesConfig, IUnitOfWork uow)
+        IRepository<SalesConfig> salesConfig, IRepository<SalesInvoice> invoices,
+        IRepository<SalesInvoicePayment> invoicePayments, IUnitOfWork uow)
     {
         _customers = customers;
         _warehouses = warehouses;
         _branchConfig = branchConfig;
         _salesConfig = salesConfig;
+        _invoices = invoices;
+        _invoicePayments = invoicePayments;
         _uow = uow;
     }
 
@@ -70,7 +75,40 @@ public sealed class CustomerService : ICustomerService
                 c.CreditLimit, c.CreditDays, c.DefaultWarehouseId, c.Status, c.BranchId, c.CreatedAt, c.UpdatedAt))
             .ToListAsync(ct);
 
-        return PagedResponse<CustomerDto>.Create(rows, query.Page, query.PageSize, total);
+        return PagedResponse<CustomerDto>.Create(await WithReceivablesAsync(rows, ct), query.Page, query.PageSize, total);
+    }
+
+    /// <summary>
+    /// Adds each customer's receivable position — the unpaid balance and count of their Posted sales
+    /// invoices, and their latest invoice payment — for just the customers on this page.
+    /// </summary>
+    private async Task<List<CustomerDto>> WithReceivablesAsync(List<CustomerDto> rows, CancellationToken ct)
+    {
+        if (rows.Count == 0) return rows;
+        var ids = rows.Select(r => r.CustomerId).ToList();
+
+        var dues = await _invoices.Query().AsNoTracking()
+            .Where(i => ids.Contains(i.CustomerId) && i.Status == SalesInvoiceStatus.Posted && i.BalanceAmount > 0)
+            .GroupBy(i => i.CustomerId)
+            .Select(g => new { CustomerId = g.Key, Amount = g.Sum(i => i.BalanceAmount), Count = g.Count() })
+            .ToDictionaryAsync(x => x.CustomerId, ct);
+
+        var lastPaid = await _invoicePayments.Query().AsNoTracking()
+            .Where(p => ids.Contains(p.SalesInvoice!.CustomerId))
+            .GroupBy(p => p.SalesInvoice!.CustomerId)
+            .Select(g => new { CustomerId = g.Key, Last = g.Max(p => p.PaymentDate) })
+            .ToDictionaryAsync(x => x.CustomerId, x => x.Last, ct);
+
+        return rows.Select(r =>
+        {
+            var due = dues.GetValueOrDefault(r.CustomerId);
+            return r with
+            {
+                OutstandingAmount = due?.Amount ?? 0m,
+                OutstandingInvoiceCount = due?.Count ?? 0,
+                LastPaymentDate = lastPaid.TryGetValue(r.CustomerId, out var last) ? last : null
+            };
+        }).ToList();
     }
 
     public async Task<ETagged<CustomerDto>?> GetAsync(int customerId, CancellationToken ct = default)
diff --git a/Backend/ERPCore/Services/DayEndReportService.cs b/Backend/ERPCore/Services/DayEndReportService.cs
new file mode 100644
index 0000000..89a8e8c
--- /dev/null
+++ b/Backend/ERPCore/Services/DayEndReportService.cs
@@ -0,0 +1,284 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Accounts;
+using ERPCore.Dtos.Reports;
+using ERPCore.Infra.Auth;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Day-End Sales Report (docs/DAY_END_SALES_REPORT_PLAN.md §4). Sales documents are stamped in
+/// UTC, so each business day is the <see cref="BusinessDayClock"/> calendar day converted to a UTC
+/// <c>[start, end)</c> window. The database does the filtering and returns slim projections; the
+/// rows are bucketed into local days here, since MariaDB can't group by a time-zone-shifted date
+/// portably and a ≤ 92-day window of slim rows is small. Cost of goods sold is the stock ledger's
+/// Out value per sale document — the same source <see cref="SalesDayEndService"/> posts COGS from.
+/// The cash figures (net cash, deposits, cash in hand) come from the Bank Deposit module's
+/// <see cref="ICashInHandService"/> (docs/BANK_DEPOSIT_MODULE_PLAN.md §9); this report owns none of them.
+/// </summary>
+public sealed class DayEndReportService : IDayEndReportService
+{
+    private const int MaxRangeDays = 92;
+    private const int IdChunk = 1000;
+
+    private readonly IRepository<SalesSlip> _slips;
+    private readonly IRepository<BundleSale> _bundles;
+    private readonly IRepository<SalesInvoice> _invoices;
+    private readonly IRepository<SalesInvoicePayment> _invoicePayments;
+    private readonly IRepository<StockLedger> _ledger;
+    private readonly IRepository<Expense> _expenses;
+    private readonly IRepository<BankDeposit> _deposits;
+    private readonly ICashInHandService _cash;
+    private readonly ICurrentBranchContext _currentBranch;
+    private readonly BusinessDayClock _clock;
+
+    public DayEndReportService(
+        IRepository<SalesSlip> slips, IRepository<BundleSale> bundles, IRepository<SalesInvoice> invoices,
+        IRepository<SalesInvoicePayment> invoicePayments, IRepository<StockLedger> ledger,
+        IRepository<Expense> expenses, IRepository<BankDeposit> deposits, ICashInHandService cash,
+        ICurrentBranchContext currentBranch, BusinessDayClock clock)
+    {
+        _slips = slips;
+        _bundles = bundles;
+        _invoices = invoices;
+        _invoicePayments = invoicePayments;
+        _ledger = ledger;
+        _expenses = expenses;
+        _deposits = deposits;
+        _cash = cash;
+        _currentBranch = currentBranch;
+        _clock = clock;
+    }
+
+    public async Task<DayEndReportDto> GetDayAsync(DateOnly? requestedDate, int? branchId, CancellationToken ct = default)
+    {
+        var date = requestedDate ?? _clock.Today;
+        var branch = EffectiveBranch(branchId);
+        var data = await LoadAsync(date, date, branch, ct);
+
+        var sales = data.Sales
+            .OrderBy(s => s.At)
+            .Select(s => new DayEndReportSaleDto(
+                s.DocType, s.DocId, s.DocNo, s.At, s.Customer, s.Total, s.Paid, s.Total - s.Paid, s.PaidBy, s.Cost, s.Total - s.Cost))
+            .ToList();
+
+        var expenses = await PostedExpenses(date, date, branch)
+            .OrderBy(e => e.ExpenseId)
+            .Select(e => new DayEndReportExpenseDto(
+                e.ExpenseId, e.DocNo, e.Category!.Name, e.Title!.Name, e.Payee, e.Amount, e.PaidAmount))
+            .ToListAsync(ct);
+
+        var depositsQuery = _deposits.Query().AsNoTracking()
+            .Where(d => d.Status == BankDepositStatus.Posted && d.BusinessDate == date);
+        if (branch is not null) depositsQuery = depositsQuery.Where(d => d.BranchId == branch);
+        var deposits = await depositsQuery
+            .OrderBy(d => d.BankDepositId)
+            .Select(d => new DayEndReportDepositDto(
+                d.BankDepositId, d.DocNo, d.ToBankAccountName, d.ToBankName, d.ToAccountNumber, d.DepositSlipNo, d.DepositDate, d.Amount))
+            .ToListAsync(ct);
+
+        return new DayEndReportDto(data.Days[0], sales, expenses, deposits, branch, _clock.Zone.Id);
+    }
+
+    public async Task<DayEndDailyReportDto> GetDailyAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct = default)
+    {
+        if (to < from)
+            throw new DomainException(ErrorCodes.DayEndReportRangeInvalid, "'to' must be on or after 'from'.", 400);
+        if (to.DayNumber - from.DayNumber + 1 > MaxRangeDays)
+            throw new DomainException(ErrorCodes.DayEndReportRangeInvalid, $"The range can be at most {MaxRangeDays} days.", 400);
+
+        var branch = EffectiveBranch(branchId);
+        var data = await LoadAsync(from, to, branch, ct);
+        return new DayEndDailyReportDto(from, to, data.Days, Sum(data.Days), branch, _clock.Zone.Id);
+    }
+
+    /// <summary>A branch-scoped (non-admin) caller always sees only their own branch, whatever they ask for.</summary>
+    private int? EffectiveBranch(int? requested) => _currentBranch.IsActive ? _currentBranch.BranchId : requested;
+
+    /// <summary>One sale, whatever document it is. Cash/Card/Other are how its Paid amount was paid.</summary>
+    private sealed record Sale(
+        string DocType, int DocId, string DocNo, DateTime At, DateOnly Day, string Customer,
+        decimal Total, decimal Paid, decimal Cash, decimal Card, decimal Other, string PaidBy, decimal Cost);
+
+    private sealed record Loaded(List<DayEndReportDayDto> Days, List<Sale> Sales);
+
+    private async Task<Loaded> LoadAsync(DateOnly from, DateOnly to, int? branch, CancellationToken ct)
+    {
+        var start = _clock.ToUtc(from);
+        var end = _clock.ToUtc(to.AddDays(1));
+
+        var slipsQuery = _slips.Query().AsNoTracking()
+            .Where(s => s.Status == SalesSlipStatus.Posted && s.SlipDate >= start && s.SlipDate < end);
+        if (branch is not null) slipsQuery = slipsQuery.Where(s => s.Warehouse!.BranchId == branch);
+        var slips = await slipsQuery
+            .Select(s => new { s.SalesSlipId, s.SlipNo, s.SlipDate, s.CustomerSnapshotName, s.GrandTotal, s.PaidAmount, s.CashAmount, s.CardAmount })
+            .ToListAsync(ct);
+
+        var bundlesQuery = _bundles.Query().AsNoTracking()
+            .Where(b => b.Status == BundleSaleStatus.Posted && b.BundleDate >= start && b.BundleDate < end);
+        if (branch is not null) bundlesQuery = bundlesQuery.Where(b => b.Warehouse!.BranchId == branch);
+        var bundles = await bundlesQuery
+            .Select(b => new { b.BundleSaleId, b.BundleNo, b.BundleDate, b.CustomerSnapshotName, b.GrandTotal, b.CashAmount, b.CardAmount })
+            .ToListAsync(ct);
+
+        var invoicesQuery = _invoices.Query().AsNoTracking()
+            .Where(i => i.Status == SalesInvoiceStatus.Posted && i.InvoiceDate >= start && i.InvoiceDate < end);
+        if (branch is not null) invoicesQuery = invoicesQuery.Where(i => i.BranchId == branch);
+        var invoices = await invoicesQuery
+            .Select(i => new { i.SalesInvoiceId, i.InvoiceNo, i.InvoiceDate, i.CustomerSnapshotName, i.NetPayable, i.PaidAmount })
+            .ToListAsync(ct);
+
+        // Every payment that matters to the window: those against its invoices (the method split of
+        // Paid), and those received inside it against earlier invoices (collections / net cash).
+        var paymentsQuery = _invoicePayments.Query().AsNoTracking()
+            .Where(p => p.SalesInvoice!.Status == SalesInvoiceStatus.Posted
+                && ((p.SalesInvoice.InvoiceDate >= start && p.SalesInvoice.InvoiceDate < end)
+                    || (p.PaymentDate >= start && p.PaymentDate < end)));
+        if (branch is not null) paymentsQuery = paymentsQuery.Where(p => p.SalesInvoice!.BranchId == branch);
+        var payments = await paymentsQuery
+            .Select(p => new { p.SalesInvoiceId, InvoiceDate = p.SalesInvoice!.InvoiceDate, p.PaymentDate, p.PaymentMethod, p.Amount })
+            .ToListAsync(ct);
+
+        var slipCost = await CostByDocAsync(DocumentTypes.SalesSlip, slips.Select(s => s.SalesSlipId), ct);
+        var bundleCost = await CostByDocAsync(DocumentTypes.BundleSale, bundles.Select(b => b.BundleSaleId), ct);
+        var invoiceCost = await CostByDocAsync(DocumentTypes.SalesInvoice, invoices.Select(i => i.SalesInvoiceId), ct);
+
+        var expenses = await PostedExpenses(from, to, branch)
+            .Select(e => new { e.ExpenseDate, e.Amount })
+            .ToListAsync(ct);
+
+        // Branch is already the effective one, so the cash service scopes it the same way.
+        var cashByDay = (await _cash.GetRangeAsync(from, to, branch, ct)).ToDictionary(c => c.Date);
+
+        var paymentsByInvoice = payments.GroupBy(p => p.SalesInvoiceId).ToDictionary(g => g.Key, g => g.ToList());
+
+        var sales = new List<Sale>(slips.Count + bundles.Count + invoices.Count);
+        sales.AddRange(slips.Select(s => new Sale(
+            "Slip", s.SalesSlipId, s.SlipNo, s.SlipDate, LocalDay(s.SlipDate), s.CustomerSnapshotName,
+            s.GrandTotal, s.PaidAmount, s.CashAmount, s.CardAmount, 0m, PaidBy(s.CashAmount, s.CardAmount, 0m, null),
+            slipCost.GetValueOrDefault(s.SalesSlipId))));
+        sales.AddRange(bundles.Select(b => new Sale(
+            "Bundle", b.BundleSaleId, b.BundleNo, b.BundleDate, LocalDay(b.BundleDate), b.CustomerSnapshotName,
+            b.GrandTotal, b.GrandTotal, b.CashAmount, b.CardAmount, 0m, PaidBy(b.CashAmount, b.CardAmount, 0m, null),
+            bundleCost.GetValueOrDefault(b.BundleSaleId))));
+        foreach (var i in invoices)
+        {
+            var own = paymentsByInvoice.GetValueOrDefault(i.SalesInvoiceId) ?? [];
+            var cash = own.Where(p => p.PaymentMethod == SalesPaymentMethod.Cash).Sum(p => p.Amount);
+            var card = own.Where(p => p.PaymentMethod == SalesPaymentMethod.Card).Sum(p => p.Amount);
+            var others = own.Where(p => p.PaymentMethod is not (SalesPaymentMethod.Cash or SalesPaymentMethod.Card)).ToList();
+            var other = others.Sum(p => p.Amount);
+            var otherMethods = others.Select(p => p.PaymentMethod).Distinct().ToList();
+            sales.Add(new Sale(
+                "Invoice", i.SalesInvoiceId, i.InvoiceNo, i.InvoiceDate, LocalDay(i.InvoiceDate), i.CustomerSnapshotName,
+                i.NetPayable, i.PaidAmount, cash, card, other,
+                PaidBy(cash, card, other, otherMethods.Count == 1 ? otherMethods[0] : null),
+                invoiceCost.GetValueOrDefault(i.SalesInvoiceId)));
+        }
+
+        var days = new List<DayEndReportDayDto>(to.DayNumber - from.DayNumber + 1);
+        for (var day = from; day <= to; day = day.AddDays(1))
+        {
+            var d = day;
+            var acc = new DayAccumulator();
+            foreach (var s in sales.Where(s => s.Day == d)) acc.AddSale(s);
+
+            var receivedToday = payments.Where(p => LocalDay(p.PaymentDate) == d).ToList();
+            acc.EarlierCollections = receivedToday.Where(p => LocalDay(p.InvoiceDate) < d).Sum(p => p.Amount);
+            acc.ExpenseTotal = expenses.Where(e => e.ExpenseDate == d).Sum(e => e.Amount);
+            acc.Cash = cashByDay[d];
+
+            days.Add(acc.ToDto(d));
+        }
+        return new Loaded(days, sales);
+    }
+
+    /// <summary>Sum of the stock ledger's Out value per document — the FIFO cost the sale consumed.</summary>
+    private async Task<Dictionary<int, decimal>> CostByDocAsync(string docType, IEnumerable<int> docIds, CancellationToken ct)
+    {
+        var result = new Dictionary<int, decimal>();
+        foreach (var chunk in docIds.Distinct().Chunk(IdChunk))
+        {
+            var rows = await _ledger.Query().AsNoTracking()
+                .Where(l => l.SourceDocType == docType && l.Direction == Direction.Out && chunk.Contains(l.SourceDocId))
+                .GroupBy(l => l.SourceDocId)
+                .Select(g => new { DocId = g.Key, Cost = g.Sum(l => l.Value) })
+                .ToListAsync(ct);
+            foreach (var r in rows) result[r.DocId] = r.Cost;
+        }
+        return result;
+    }
+
+    private static string PaidBy(decimal cash, decimal card, decimal other, SalesPaymentMethod? singleOther)
+    {
+        var ways = (cash > 0 ? 1 : 0) + (card > 0 ? 1 : 0) + (other > 0 ? 1 : 0);
+        if (ways == 0) return "Unpaid";
+        if (ways > 1 || (other > 0 && singleOther is null)) return "Mixed";
+        if (cash > 0) return "Cash";
+        if (card > 0) return "Card";
+        return singleOther == SalesPaymentMethod.Cheque ? "Cheque" : "Bank transfer";
+    }
+
+    private IQueryable<Expense> PostedExpenses(DateOnly from, DateOnly to, int? branch)
+    {
+        var q = _expenses.Query().AsNoTracking()
+            .Where(e => e.Status == ExpenseStatus.Posted && e.ExpenseDate >= from && e.ExpenseDate <= to);
+        return branch is null ? q : q.Where(e => e.BranchId == branch);
+    }
+
+    private DateOnly LocalDay(DateTime utc) => _clock.LocalDay(utc);
+
+    /// <summary>Flows are summed; cash in hand is a balance, so the range opens with its first day and closes with its last.</summary>
+    private static DayEndReportDayDto Sum(IReadOnlyList<DayEndReportDayDto> days) => new(
+        null,
+        days.Sum(d => d.TotalSales), days.Sum(d => d.PaidAmount), days.Sum(d => d.DueAmount),
+        days.Sum(d => d.PaidByCash), days.Sum(d => d.PaidByCard), days.Sum(d => d.PaidByOther),
+        days.Sum(d => d.SalesCount), days.Sum(d => d.CashSalesCount), days.Sum(d => d.CardSalesCount),
+        days.Sum(d => d.MixedSalesCount), days.Sum(d => d.OtherSalesCount), days.Sum(d => d.UnpaidSalesCount),
+        days.Sum(d => d.ExpenseTotal), days.Sum(d => d.Income),
+        days.Sum(d => d.CostOfGoodsSold), days.Sum(d => d.GrossProfit), days.Sum(d => d.NetProfit),
+        days.Sum(d => d.EarlierInvoiceCollections), days.Sum(d => d.NetCash),
+        days[0].OpeningCashInHand, days.Sum(d => d.CashDeposited), days[^1].ClosingCashInHand);
+
+    private sealed class DayAccumulator
+    {
+        private decimal _total, _paid, _cash, _card, _other, _cost;
+        private int _count, _cashCount, _cardCount, _mixedCount, _otherCount, _unpaidCount;
+        public decimal ExpenseTotal { get; set; }
+        public decimal EarlierCollections { get; set; }
+        public CashPositionDto? Cash { get; set; }
+
+        /// <summary>A sale counts as a cash/card/other sale when that is the only way it was paid,
+        /// mixed when paid more than one way, unpaid when nothing has been paid yet.</summary>
+        public void AddSale(Sale s)
+        {
+            _total += s.Total;
+            _paid += s.Paid;
+            _cash += s.Cash;
+            _card += s.Card;
+            _other += s.Other;
+            _cost += s.Cost;
+            _count++;
+
+            var ways = (s.Cash > 0 ? 1 : 0) + (s.Card > 0 ? 1 : 0) + (s.Other > 0 ? 1 : 0);
+            if (ways == 0) _unpaidCount++;
+            else if (ways > 1) _mixedCount++;
+            else if (s.Cash > 0) _cashCount++;
+            else if (s.Card > 0) _cardCount++;
+            else _otherCount++;
+        }
+
+        public DayEndReportDayDto ToDto(DateOnly date) => new(
+            date, _total, _paid, _total - _paid, _cash, _card, _other,
+            _count, _cashCount, _cardCount, _mixedCount, _otherCount, _unpaidCount,
+            ExpenseTotal, _total - ExpenseTotal,
+            _cost, _total - _cost, _total - _cost - ExpenseTotal,
+            EarlierCollections,
+            Cash?.NetCash ?? 0m, Cash?.Opening ?? 0m, Cash?.Deposited ?? 0m, Cash?.Closing ?? 0m);
+    }
+}
diff --git a/Backend/ERPCore/Services/ExpensePaymentService.cs b/Backend/ERPCore/Services/ExpensePaymentService.cs
new file mode 100644
index 0000000..ed2ad94
--- /dev/null
+++ b/Backend/ERPCore/Services/ExpensePaymentService.cs
@@ -0,0 +1,189 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Expenses;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Gl;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Payments against a Posted expense (docs/EXPENSE_MODULE_PLAN.md §4). One submission may
+/// split across several cash/bank accounts; it posts a single GL journal entry (Debit Accrued
+/// Expenses / Credit each account) and records one <see cref="ExpensePayment"/> row per line,
+/// all sharing that journal number. Same call-GL-before-commit pattern as
+/// <see cref="PurchaseInvoicePaymentService"/>, so a rejected/unreachable GL post rolls the
+/// whole payment back. Post &amp; Pay runs the accrual and a full or partial payment in one transaction.
+/// </summary>
+public sealed class ExpensePaymentService : IExpensePaymentService
+{
+    private readonly IRepository<Expense> _expenses;
+    private readonly IRepository<ExpensePayment> _payments;
+    private readonly ExpenseService _expenseService;
+    private readonly IGeneralLedgerService _gl;
+    private readonly ICurrentUser _currentUser;
+    private readonly IUnitOfWork _uow;
+    private readonly string _glAccruedExpensesCode;
+
+    public ExpensePaymentService(
+        IRepository<Expense> expenses, IRepository<ExpensePayment> payments, ExpenseService expenseService,
+        IGeneralLedgerService gl, ICurrentUser currentUser, IUnitOfWork uow, IConfiguration configuration)
+    {
+        _expenses = expenses;
+        _payments = payments;
+        _expenseService = expenseService;
+        _gl = gl;
+        _currentUser = currentUser;
+        _uow = uow;
+        _glAccruedExpensesCode = configuration["Expense:GlAccruedExpensesCode"] ?? string.Empty;
+    }
+
+    public async Task<IReadOnlyList<ExpensePaymentDto>> PayAsync(int expenseId, CreateExpensePaymentRequest request, CancellationToken ct = default)
+    {
+        var expense = await _expenseService.LoadAsync(expenseId, tracking: true, ct)
+            ?? throw new NotFoundException($"Expense {expenseId} was not found.");
+
+        if (expense.Status != ExpenseStatus.Posted || expense.BalanceAmount <= 0)
+            throw new DomainException(ErrorCodes.ExpenseNotPayable,
+                $"Expense {expense.DocNo} must be posted with a balance outstanding before it can be paid.", 409);
+
+        var total = ValidateRequest(request);
+        if (total > expense.BalanceAmount)
+            throw new DomainException(ErrorCodes.ExpensePaymentExceedsBalance,
+                $"Payment total {total} exceeds the remaining balance {expense.BalanceAmount}.", 400);
+
+        var accounts = await ResolveAccountsAsync(request, ct);
+        var (paymentDay, paymentDate) = ResolvePaymentDate(request.PaymentDate, DateTime.UtcNow);
+
+        var recorded = await _uow.ExecuteInTransactionAsync(
+            token => RecordPaymentAsync(expense, request, accounts, paymentDay, paymentDate, token), ct);
+
+        return recorded.Select(ExpenseService.MapPayment).ToList();
+    }
+
+    public async Task<ExpenseDto> PostAndPayAsync(int expenseId, CreateExpensePaymentRequest request, CancellationToken ct = default)
+    {
+        var expense = await _expenseService.LoadAsync(expenseId, tracking: true, ct)
+            ?? throw new NotFoundException($"Expense {expenseId} was not found.");
+
+        if (expense.Status != ExpenseStatus.Draft)
+            throw new DomainException(ErrorCodes.ExpenseNotDraft, $"Expense {expense.DocNo} is {expense.Status}; use the payments endpoint instead.", 409);
+
+        // Full or partial: whatever is left stays as the balance, payable later like any Posted expense.
+        var total = ValidateRequest(request);
+        if (total > expense.Amount)
+            throw new DomainException(ErrorCodes.ExpensePaymentExceedsBalance,
+                $"Payment total {total} exceeds the expense amount {expense.Amount}.", 400);
+
+        var accounts = await ResolveAccountsAsync(request, ct);
+        var (paymentDay, paymentDate) = ResolvePaymentDate(request.PaymentDate, DateTime.UtcNow);
+
+        await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            await _expenseService.PostInCurrentTransactionAsync(expense, token);
+            return await RecordPaymentAsync(expense, request, accounts, paymentDay, paymentDate, token);
+        }, ct);
+
+        return ExpenseService.Map(expense);
+    }
+
+    public async Task<IReadOnlyList<ExpensePaymentDto>> ListAsync(int expenseId, CancellationToken ct = default)
+    {
+        if (!await _expenses.Query().AnyAsync(x => x.ExpenseId == expenseId, ct))
+            throw new NotFoundException($"Expense {expenseId} was not found.");
+
+        var payments = await _payments.Query().AsNoTracking()
+            .Where(p => p.ExpenseId == expenseId)
+            .OrderByDescending(p => p.ExpensePaymentId)
+            .ToListAsync(ct);
+        return payments.Select(ExpenseService.MapPayment).ToList();
+    }
+
+    /// <summary>Posts the settlement journal and records the payment rows. Runs inside the caller's transaction.</summary>
+    private async Task<List<ExpensePayment>> RecordPaymentAsync(
+        Expense expense, CreateExpensePaymentRequest request, IReadOnlyDictionary<long, GlBankAccount> accounts,
+        DateOnly paymentDay, DateTime paymentDate, CancellationToken ct)
+    {
+        var total = request.Lines.Sum(l => l.Amount);
+        var narration = $"Payment of expense {expense.DocNo}";
+        var glLines = new List<GlJournalEntryLineRequest> { new(_glAccruedExpensesCode, total, 0m, narration) };
+        glLines.AddRange(request.Lines.Select(l => new GlJournalEntryLineRequest(accounts[l.GlBankAccountId].GlAccountCode, 0m, l.Amount, narration)));
+
+        var period = await _gl.GetPeriodByDateAsync(paymentDay, ct);
+        var posted = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+        {
+            PeriodId = period.PeriodId,
+            EntryDate = paymentDay,
+            SourceModule = "EXPENSE_PAYMENT",
+            Reference = expense.DocNo,
+            Narration = narration,
+            Lines = glLines
+        }, ct);
+
+        var actor = _currentUser.AuditUserId;
+        var now = DateTime.UtcNow;
+        var chequeNo = request.PaymentMethod == ExpensePaymentMethod.Cheque ? request.ChequeNo?.Trim() : null;
+        var reference = string.IsNullOrWhiteSpace(request.Reference) ? null : request.Reference.Trim();
+
+        var rows = request.Lines.Select(l => new ExpensePayment
+        {
+            ExpenseId = expense.ExpenseId,
+            Amount = l.Amount,
+            PaymentDate = paymentDate,
+            PaymentMethod = request.PaymentMethod,
+            GlBankAccountId = l.GlBankAccountId,
+            BankAccountName = accounts[l.GlBankAccountId].AccountName,
+            ChequeNo = chequeNo,
+            Reference = reference,
+            GlJournalNo = posted.JournalNo,
+            CreatedBy = actor,
+            CreatedAt = now
+        }).ToList();
+
+        foreach (var row in rows) expense.Payments.Add(row);
+        expense.PaidAmount += total;
+        expense.BalanceAmount -= total;
+        expense.PaymentStatus = ExpenseService.DerivePaymentStatus(expense.PaidAmount, expense.BalanceAmount);
+        expense.UpdatedAt = now;
+
+        return rows;
+    }
+
+    private static decimal ValidateRequest(CreateExpensePaymentRequest request)
+    {
+        if (request.Lines.Count == 0)
+            throw new DomainException(ErrorCodes.Validation, "Add at least one payment line.", 400);
+        if (request.Lines.Any(l => l.Amount <= 0))
+            throw new DomainException(ErrorCodes.Validation, "Every payment line needs an amount greater than zero.", 400);
+        if (request.PaymentMethod == ExpensePaymentMethod.Cheque && string.IsNullOrWhiteSpace(request.ChequeNo))
+            throw new DomainException(ErrorCodes.ExpenseChequeNoRequired, "Enter the cheque number for a cheque payment.", 400);
+        return request.Lines.Sum(l => l.Amount);
+    }
+
+    private async Task<IReadOnlyDictionary<long, GlBankAccount>> ResolveAccountsAsync(CreateExpensePaymentRequest request, CancellationToken ct)
+    {
+        var all = await _gl.ListBankAccountsAsync(ct);
+        var result = new Dictionary<long, GlBankAccount>();
+        foreach (var id in request.Lines.Select(l => l.GlBankAccountId).Distinct())
+        {
+            result[id] = all.FirstOrDefault(a => a.AccountId == id)
+                ?? throw new DomainException(ErrorCodes.ExpenseBankAccountNotFound, $"Bank/cash account {id} was not found.", 404);
+        }
+        return result;
+    }
+
+    /// <summary>Same rule as <see cref="PurchaseInvoicePaymentService"/>: omitted ⇒ today, one day of
+    /// slack on "future" for clients east of UTC; a back-dated payment is stamped at that day's start.</summary>
+    private static (DateOnly Day, DateTime Stamp) ResolvePaymentDate(DateOnly? requested, DateTime now)
+    {
+        var today = DateOnly.FromDateTime(now);
+        var day = requested ?? today;
+        if (day > today.AddDays(1))
+            throw new DomainException(ErrorCodes.Validation, "Payment date cannot be in the future.", 400);
+        return (day, day >= today ? now : day.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc));
+    }
+}
diff --git a/Backend/ERPCore/Services/ExpenseService.cs b/Backend/ERPCore/Services/ExpenseService.cs
new file mode 100644
index 0000000..9800c5d
--- /dev/null
+++ b/Backend/ERPCore/Services/ExpenseService.cs
@@ -0,0 +1,390 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Expenses;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Gl;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Business expense bills (docs/EXPENSE_MODULE_PLAN.md §4). Draft is editable and has no GL
+/// impact; Post accrues it (Debit the title's expense account / Credit Accrued Expenses) via a
+/// real GL journal entry posted before commit — same atomicity approach as
+/// <see cref="PurchaseInvoiceService.PostAsync"/>, so a GL rejection rolls the post back.
+/// Payments settle the accrual (<see cref="ExpensePaymentService"/>). Cancelling a Posted
+/// expense with no payments posts the reversing entry.
+/// </summary>
+public sealed class ExpenseService : IExpenseService
+{
+    private readonly IRepository<Expense> _expenses;
+    private readonly IRepository<ExpenseTitle> _titles;
+    private readonly IRepository<Vendor> _vendors;
+    private readonly ICurrentUser _currentUser;
+    private readonly INumberSequenceService _numbers;
+    private readonly IBranchConfigService _branchConfig;
+    private readonly IUnitOfWork _uow;
+    private readonly IGeneralLedgerService _gl;
+    private readonly string _glAccruedExpensesCode;
+
+    public ExpenseService(
+        IRepository<Expense> expenses, IRepository<ExpenseTitle> titles, IRepository<Vendor> vendors,
+        ICurrentUser currentUser, INumberSequenceService numbers, IBranchConfigService branchConfig,
+        IUnitOfWork uow, IGeneralLedgerService gl, IConfiguration configuration)
+    {
+        _expenses = expenses;
+        _titles = titles;
+        _vendors = vendors;
+        _currentUser = currentUser;
+        _numbers = numbers;
+        _branchConfig = branchConfig;
+        _uow = uow;
+        _gl = gl;
+        _glAccruedExpensesCode = configuration["Expense:GlAccruedExpensesCode"] ?? string.Empty;
+    }
+
+    public async Task<PagedResponse<ExpenseSummaryDto>> ListAsync(PageQuery query, ExpenseListFilter filter, CancellationToken ct = default)
+    {
+        IQueryable<Expense> q = _expenses.Query().AsNoTracking().Include(x => x.Category).Include(x => x.Title);
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(x => EF.Functions.Like(x.DocNo, $"%{term}%")
+                || (x.Payee != null && EF.Functions.Like(x.Payee, $"%{term}%"))
+                || (x.BillReference != null && EF.Functions.Like(x.BillReference, $"%{term}%")));
+        }
+        if (filter.Status is not null) q = q.Where(x => x.Status == filter.Status);
+        if (filter.PaymentStatus is not null) q = q.Where(x => x.Status == ExpenseStatus.Posted && x.PaymentStatus == filter.PaymentStatus);
+        if (filter.CategoryId is not null) q = q.Where(x => x.ExpenseCategoryId == filter.CategoryId);
+        if (filter.TitleId is not null) q = q.Where(x => x.ExpenseTitleId == filter.TitleId);
+        if (filter.From is not null) q = q.Where(x => x.ExpenseDate >= filter.From);
+        if (filter.To is not null) q = q.Where(x => x.ExpenseDate <= filter.To);
+        if (filter.OverdueOnly)
+        {
+            var today = DateOnly.FromDateTime(DateTime.UtcNow);
+            q = q.Where(x => x.Status == ExpenseStatus.Posted && x.BalanceAmount > 0 && x.DueDate != null && x.DueDate < today);
+        }
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderByDescending(x => x.ExpenseDate).ThenByDescending(x => x.ExpenseId)
+            .Skip(query.Skip).Take(query.PageSize).ToListAsync(ct);
+
+        return PagedResponse<ExpenseSummaryDto>.Create(rows.Select(MapSummary).ToList(), query.Page, query.PageSize, total);
+    }
+
+    public async Task<ETagged<ExpenseDto>?> GetAsync(int expenseId, CancellationToken ct = default)
+    {
+        var expense = await LoadAsync(expenseId, tracking: false, ct);
+        return expense is null ? null : new ETagged<ExpenseDto>(Map(expense), expense.RowVersion);
+    }
+
+    public async Task<ETagged<ExpenseDto>> CreateAsync(CreateExpenseRequest request, CancellationToken ct = default)
+    {
+        var title = await ValidateTitleAsync(request, ct);
+        var vendorName = await ValidateVendorAsync(request.VendorId, ct);
+        ValidateDates(request);
+
+        var branchId = request.BranchId > 0
+            ? await _branchConfig.ResolveBranchIdAsync(request.BranchId, ct)
+            : await _branchConfig.ResolveDefaultBranchIdAsync(ct);
+
+        var expense = await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            var entity = new Expense
+            {
+                DocNo = await _numbers.NextAsync(DocumentTypes.Expense, branchId, token),
+                BranchId = branchId,
+                Status = ExpenseStatus.Draft,
+                PaymentStatus = ExpensePaymentStatus.Unpaid,
+                CreatedBy = _currentUser.AuditUserId,
+                CreatedAt = DateTime.UtcNow
+            };
+            Apply(entity, request, vendorName);
+            await _expenses.AddAsync(entity, token);
+            return entity;
+        }, ct);
+
+        expense.Category = title.Category;
+        expense.Title = title;
+        return new ETagged<ExpenseDto>(Map(expense), expense.RowVersion);
+    }
+
+    public async Task<ETagged<ExpenseDto>> UpdateAsync(int expenseId, UpdateExpenseRequest request, uint expectedRowVersion, CancellationToken ct = default)
+    {
+        var expense = await LoadAsync(expenseId, tracking: true, ct)
+            ?? throw new NotFoundException($"Expense {expenseId} was not found.");
+
+        if (expense.RowVersion != expectedRowVersion)
+            throw new DomainException(ErrorCodes.ConcurrencyConflict, "The expense was modified by another request.", 412);
+        EnsureDraft(expense, "edited");
+
+        var title = await ValidateTitleAsync(request, ct);
+        var vendorName = await ValidateVendorAsync(request.VendorId, ct);
+        ValidateDates(request);
+
+        if (request.BranchId > 0 && request.BranchId != expense.BranchId)
+            expense.BranchId = await _branchConfig.ResolveBranchIdAsync(request.BranchId, ct);
+
+        Apply(expense, request, vendorName);
+        expense.Category = title.Category;
+        expense.Title = title;
+        expense.UpdatedAt = DateTime.UtcNow;
+
+        await SaveAsync(ct);
+        return new ETagged<ExpenseDto>(Map(expense), expense.RowVersion);
+    }
+
+    public async Task DeleteAsync(int expenseId, CancellationToken ct = default)
+    {
+        var expense = await _expenses.Query().FirstOrDefaultAsync(x => x.ExpenseId == expenseId, ct)
+            ?? throw new NotFoundException($"Expense {expenseId} was not found.");
+        EnsureDraft(expense, "deleted");
+
+        _expenses.Remove(expense);
+        await _uow.SaveChangesAsync(ct);
+    }
+
+    public async Task<ExpenseDto> PostAsync(int expenseId, CancellationToken ct = default)
+    {
+        var expense = await LoadAsync(expenseId, tracking: true, ct)
+            ?? throw new NotFoundException($"Expense {expenseId} was not found.");
+
+        await _uow.ExecuteInTransactionAsync(token => PostInCurrentTransactionAsync(expense, token), ct);
+        return Map(expense);
+    }
+
+    /// <summary>
+    /// Posts the accrual entry and flips the expense to Posted. Must run inside the caller's
+    /// transaction (the caller commits) — shared with <see cref="ExpensePaymentService.PostAndPayAsync"/>
+    /// so Post &amp; Pay is one atomic unit.
+    /// </summary>
+    internal async Task<int> PostInCurrentTransactionAsync(Expense expense, CancellationToken ct)
+    {
+        EnsureDraft(expense, "posted");
+        var title = expense.Title ?? throw new InvalidOperationException("Expense title must be loaded before posting.");
+        if (title.Status != EntityStatus.Active)
+            throw new DomainException(ErrorCodes.ExpenseTitleInactive, $"Expense title '{title.Name}' is inactive — pick another title before posting.", 409);
+
+        var now = DateTime.UtcNow;
+        var narration = $"{expense.Category?.Name} - {title.Name} ({expense.DocNo})";
+        var period = await _gl.GetPeriodByDateAsync(expense.ExpenseDate, ct);
+        var posted = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+        {
+            PeriodId = period.PeriodId,
+            EntryDate = expense.ExpenseDate,
+            SourceModule = "EXPENSE",
+            Reference = expense.DocNo,
+            Narration = narration,
+            Lines =
+            [
+                new GlJournalEntryLineRequest(title.GlExpenseAccountCode, expense.Amount, 0m, narration),
+                new GlJournalEntryLineRequest(_glAccruedExpensesCode, 0m, expense.Amount, narration)
+            ]
+        }, ct);
+
+        expense.Status = ExpenseStatus.Posted;
+        expense.GlExpenseAccountCode = title.GlExpenseAccountCode;
+        expense.GlJournalNo = posted.JournalNo;
+        expense.GlPostedAt = now;
+        expense.UpdatedAt = now;
+        return 0;
+    }
+
+    public async Task<ExpenseDto> CancelAsync(int expenseId, CancelExpenseRequest request, CancellationToken ct = default)
+    {
+        var expense = await LoadAsync(expenseId, tracking: true, ct)
+            ?? throw new NotFoundException($"Expense {expenseId} was not found.");
+
+        if (expense.Status == ExpenseStatus.Cancelled)
+            throw new ConflictException($"Expense {expense.DocNo} is already cancelled.");
+        if (expense.PaidAmount > 0)
+            throw new DomainException(ErrorCodes.ExpenseHasPayments, $"Expense {expense.DocNo} has payments recorded and cannot be cancelled.", 409);
+
+        var now = DateTime.UtcNow;
+        await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            // A Draft never reached GL, so there is nothing to reverse.
+            if (expense.Status == ExpenseStatus.Posted)
+            {
+                var today = DateOnly.FromDateTime(now);
+                var narration = $"Cancellation of expense {expense.DocNo}";
+                var period = await _gl.GetPeriodByDateAsync(today, token);
+                var reversal = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+                {
+                    PeriodId = period.PeriodId,
+                    EntryDate = today,
+                    SourceModule = "EXPENSE",
+                    Reference = expense.DocNo,
+                    Narration = narration,
+                    Lines =
+                    [
+                        new GlJournalEntryLineRequest(_glAccruedExpensesCode, expense.Amount, 0m, narration),
+                        new GlJournalEntryLineRequest(expense.GlExpenseAccountCode ?? string.Empty, 0m, expense.Amount, narration)
+                    ]
+                }, token);
+                expense.GlReversalJournalNo = reversal.JournalNo;
+            }
+
+            expense.Status = ExpenseStatus.Cancelled;
+            expense.CancelReason = request.Reason.Trim();
+            expense.UpdatedAt = now;
+            return 0;
+        }, ct);
+
+        return Map(expense);
+    }
+
+    public async Task<ExpenseSummaryReportDto> GetSummaryAsync(DateOnly? from, DateOnly? to, CancellationToken ct = default)
+    {
+        var today = DateOnly.FromDateTime(DateTime.UtcNow);
+        var start = from ?? new DateOnly(today.Year, today.Month, 1);
+        var end = to ?? start.AddMonths(1).AddDays(-1);
+        if (end < start)
+            throw new DomainException(ErrorCodes.Validation, "'to' must not be before 'from'.", 400);
+
+        var posted = _expenses.Query().AsNoTracking().Where(x => x.Status == ExpenseStatus.Posted);
+
+        var inRange = await posted
+            .Where(x => x.ExpenseDate >= start && x.ExpenseDate <= end)
+            .Select(x => new
+            {
+                x.ExpenseCategoryId, CategoryName = x.Category!.Name, CategorySort = x.Category.SortOrder,
+                x.ExpenseTitleId, TitleName = x.Title!.Name, x.Amount, x.PaidAmount, x.BalanceAmount
+            })
+            .ToListAsync(ct);
+
+        var outstanding = await posted.Where(x => x.BalanceAmount > 0)
+            .Select(x => new { x.BalanceAmount, x.DueDate })
+            .ToListAsync(ct);
+        var overdue = outstanding.Where(x => x.DueDate != null && x.DueDate < today).ToList();
+        var draftCount = await _expenses.Query().CountAsync(x => x.Status == ExpenseStatus.Draft, ct);
+
+        var categories = inRange
+            .GroupBy(x => new { x.ExpenseCategoryId, x.CategoryName, x.CategorySort })
+            .OrderBy(g => g.Key.CategorySort).ThenBy(g => g.Key.CategoryName)
+            .Select(g => new ExpenseCategoryTotalDto(
+                g.Key.ExpenseCategoryId, g.Key.CategoryName, g.Sum(x => x.Amount), g.Count(),
+                g.GroupBy(x => new { x.ExpenseTitleId, x.TitleName })
+                    .OrderByDescending(t => t.Sum(x => x.Amount))
+                    .Select(t => new ExpenseTitleTotalDto(t.Key.ExpenseTitleId, t.Key.TitleName, t.Sum(x => x.Amount), t.Count()))
+                    .ToList()))
+            .ToList();
+
+        return new ExpenseSummaryReportDto(
+            start, end,
+            inRange.Sum(x => x.Amount), inRange.Sum(x => x.PaidAmount), inRange.Sum(x => x.BalanceAmount), inRange.Count,
+            outstanding.Sum(x => x.BalanceAmount), overdue.Sum(x => x.BalanceAmount), overdue.Count, draftCount,
+            categories);
+    }
+
+    internal Task<Expense?> LoadAsync(int expenseId, bool tracking, CancellationToken ct)
+    {
+        var q = _expenses.Query()
+            .Include(x => x.Category)
+            .Include(x => x.Title)
+            .Include(x => x.Vendor)
+            .Include(x => x.Payments);
+        return (tracking ? q : q.AsNoTracking()).FirstOrDefaultAsync(x => x.ExpenseId == expenseId, ct);
+    }
+
+    private async Task<ExpenseTitle> ValidateTitleAsync(ExpenseRequestBase request, CancellationToken ct)
+    {
+        // Tracked on purpose: UpdateAsync assigns this to the tracked expense's navigations, and
+        // identity resolution hands back the instance the expense already loaded.
+        var title = await _titles.Query().Include(t => t.Category)
+            .FirstOrDefaultAsync(t => t.ExpenseTitleId == request.ExpenseTitleId, ct)
+            ?? throw new DomainException(ErrorCodes.Validation, $"Expense title {request.ExpenseTitleId} does not exist.", 422);
+
+        if (title.ExpenseCategoryId != request.ExpenseCategoryId)
+            throw new DomainException(ErrorCodes.ExpenseTitleCategoryMismatch, $"Title '{title.Name}' does not belong to the selected category.", 422);
+        if (title.Status != EntityStatus.Active || title.Category?.Status != EntityStatus.Active)
+            throw new DomainException(ErrorCodes.ExpenseTitleInactive, $"Expense title '{title.Name}' or its category is inactive.", 422);
+
+        return title;
+    }
+
+    private async Task<string?> ValidateVendorAsync(int? vendorId, CancellationToken ct)
+    {
+        if (vendorId is null) return null;
+        return await _vendors.Query().AsNoTracking().Where(v => v.VendorId == vendorId).Select(v => v.Name).FirstOrDefaultAsync(ct)
+            ?? throw new DomainException(ErrorCodes.Validation, $"Vendor {vendorId} does not exist.", 422);
+    }
+
+    private static void ValidateDates(ExpenseRequestBase request)
+    {
+        // One day of slack, as with payment dates: the client sends its local date.
+        if (request.ExpenseDate > DateOnly.FromDateTime(DateTime.UtcNow).AddDays(1))
+            throw new DomainException(ErrorCodes.Validation, "Expense date cannot be in the future.", 400);
+        if (request.DueDate is not null && request.DueDate < request.ExpenseDate)
+            throw new DomainException(ErrorCodes.Validation, "Due date cannot be before the expense date.", 400);
+    }
+
+    private static void Apply(Expense expense, ExpenseRequestBase request, string? vendorName)
+    {
+        expense.ExpenseDate = request.ExpenseDate;
+        expense.DueDate = request.DueDate;
+        expense.ExpenseCategoryId = request.ExpenseCategoryId;
+        expense.ExpenseTitleId = request.ExpenseTitleId;
+        expense.VendorId = request.VendorId;
+        // A linked vendor names the payee unless one was typed explicitly.
+        expense.Payee = Normalize(request.Payee) ?? vendorName;
+        expense.BillReference = Normalize(request.BillReference);
+        expense.Description = Normalize(request.Description);
+        expense.PeriodMonth = Normalize(request.PeriodMonth);
+        expense.Amount = request.Amount;
+        expense.PaidAmount = 0m;
+        expense.BalanceAmount = request.Amount;
+        expense.PaymentStatus = ExpensePaymentStatus.Unpaid;
+    }
+
+    private static void EnsureDraft(Expense expense, string verb)
+    {
+        if (expense.Status != ExpenseStatus.Draft)
+            throw new DomainException(ErrorCodes.ExpenseNotDraft, $"Expense {expense.DocNo} is {expense.Status} and cannot be {verb}.", 409);
+    }
+
+    private async Task SaveAsync(CancellationToken ct)
+    {
+        try
+        {
+            await _uow.SaveChangesAsync(ct);
+        }
+        catch (DbUpdateConcurrencyException)
+        {
+            throw new DomainException(ErrorCodes.ConcurrencyConflict, "The expense was modified by another request.", 412);
+        }
+    }
+
+    private static string? Normalize(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+
+    internal static ExpensePaymentStatus DerivePaymentStatus(decimal paidAmount, decimal balanceAmount) =>
+        balanceAmount <= 0 ? ExpensePaymentStatus.Paid
+        : paidAmount > 0 ? ExpensePaymentStatus.PartiallyPaid
+        : ExpensePaymentStatus.Unpaid;
+
+    private static ExpenseSummaryDto MapSummary(Expense x) => new(
+        x.ExpenseId, x.DocNo, x.BranchId, x.ExpenseDate, x.DueDate,
+        x.ExpenseCategoryId, x.Category?.Name ?? string.Empty, x.ExpenseTitleId, x.Title?.Name ?? string.Empty,
+        x.Payee, x.BillReference, x.PeriodMonth, x.Amount, x.PaidAmount, x.BalanceAmount,
+        x.Status, x.PaymentStatus, x.GlJournalNo, x.CreatedAt);
+
+    internal static ExpenseDto Map(Expense x) => new(
+        x.ExpenseId, x.DocNo, x.BranchId, x.ExpenseDate, x.DueDate,
+        x.ExpenseCategoryId, x.Category?.Name ?? string.Empty, x.ExpenseTitleId, x.Title?.Name ?? string.Empty,
+        x.Payee, x.VendorId, x.Vendor?.Name, x.BillReference, x.Description, x.PeriodMonth,
+        x.Amount, x.PaidAmount, x.BalanceAmount, x.Status, x.PaymentStatus,
+        x.GlExpenseAccountCode, x.GlJournalNo, x.GlPostedAt, x.GlReversalJournalNo, x.CancelReason,
+        x.CreatedBy, x.CreatedAt, x.UpdatedAt,
+        x.Payments.OrderByDescending(p => p.ExpensePaymentId).Select(MapPayment).ToList());
+
+    internal static ExpensePaymentDto MapPayment(ExpensePayment p) => new(
+        p.ExpensePaymentId, p.ExpenseId, p.Amount, p.PaymentDate, p.PaymentMethod,
+        p.GlBankAccountId, p.BankAccountName, p.ChequeNo, p.Reference, p.GlJournalNo, p.CreatedAt);
+}
diff --git a/Backend/ERPCore/Services/ExpenseSetupService.cs b/Backend/ERPCore/Services/ExpenseSetupService.cs
new file mode 100644
index 0000000..54f27d8
--- /dev/null
+++ b/Backend/ERPCore/Services/ExpenseSetupService.cs
@@ -0,0 +1,133 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Expenses;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Expense categories and titles. Categories are the fixed seeded four (no create — only their
+/// active flag changes). Seeded rows (<c>IsSystem</c>) keep their names — they can be
+/// deactivated, and a title's GL account code can be corrected — while user-added titles
+/// are fully editable. Nothing is hard-deleted: expenses reference titles, so retiring one
+/// means setting it Inactive (it stops being offered on new expenses).
+/// </summary>
+public sealed class ExpenseSetupService : IExpenseSetupService
+{
+    private readonly IRepository<ExpenseCategory> _categories;
+    private readonly IRepository<ExpenseTitle> _titles;
+    private readonly IUnitOfWork _uow;
+
+    public ExpenseSetupService(IRepository<ExpenseCategory> categories, IRepository<ExpenseTitle> titles, IUnitOfWork uow)
+    {
+        _categories = categories;
+        _titles = titles;
+        _uow = uow;
+    }
+
+    public async Task<IReadOnlyList<ExpenseCategoryDto>> ListAsync(bool includeInactive, CancellationToken ct = default)
+    {
+        var categories = await _categories.Query().AsNoTracking()
+            .Include(c => c.Titles)
+            .Where(c => includeInactive || c.Status == EntityStatus.Active)
+            .OrderBy(c => c.SortOrder).ThenBy(c => c.Name)
+            .ToListAsync(ct);
+
+        return categories.Select(c => Map(c, includeInactive)).ToList();
+    }
+
+    public async Task<ExpenseCategoryDto> UpdateCategoryAsync(int expenseCategoryId, UpdateExpenseCategoryRequest request, CancellationToken ct = default)
+    {
+        var category = await _categories.Query().Include(c => c.Titles)
+            .FirstOrDefaultAsync(c => c.ExpenseCategoryId == expenseCategoryId, ct)
+            ?? throw new NotFoundException($"Expense category {expenseCategoryId} was not found.");
+
+        var name = request.Name.Trim();
+        if (name != category.Name)
+        {
+            if (category.IsSystem)
+                throw new DomainException(ErrorCodes.ExpenseSystemRowReadOnly, $"'{category.Name}' is a built-in category and cannot be renamed.", 409);
+            if (await _categories.Query().AnyAsync(c => c.Name == name && c.ExpenseCategoryId != expenseCategoryId, ct))
+                throw new DomainException(ErrorCodes.DuplicateExpenseCategory, $"An expense category named '{name}' already exists.", 409);
+            category.Name = name;
+        }
+
+        category.Status = request.Status;
+        category.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+
+        return Map(category, includeInactive: true);
+    }
+
+    public async Task<ExpenseTitleDto> CreateTitleAsync(int expenseCategoryId, CreateExpenseTitleRequest request, CancellationToken ct = default)
+    {
+        if (!await _categories.Query().AnyAsync(c => c.ExpenseCategoryId == expenseCategoryId, ct))
+            throw new NotFoundException($"Expense category {expenseCategoryId} was not found.");
+
+        var name = request.Name.Trim();
+        await EnsureTitleNameIsUniqueAsync(expenseCategoryId, name, excludingTitleId: null, ct);
+
+        var nextSort = (await _titles.Query().Where(t => t.ExpenseCategoryId == expenseCategoryId)
+            .MaxAsync(t => (int?)t.SortOrder, ct) ?? 0) + 1;
+        var title = new ExpenseTitle
+        {
+            ExpenseCategoryId = expenseCategoryId,
+            Name = name,
+            GlExpenseAccountCode = request.GlExpenseAccountCode.Trim(),
+            IsSystem = false,
+            SortOrder = nextSort,
+            CreatedAt = DateTime.UtcNow
+        };
+        await _titles.AddAsync(title, ct);
+        await _uow.SaveChangesAsync(ct);
+
+        return Map(title);
+    }
+
+    public async Task<ExpenseTitleDto> UpdateTitleAsync(int expenseTitleId, UpdateExpenseTitleRequest request, CancellationToken ct = default)
+    {
+        var title = await _titles.Query().FirstOrDefaultAsync(t => t.ExpenseTitleId == expenseTitleId, ct)
+            ?? throw new NotFoundException($"Expense title {expenseTitleId} was not found.");
+
+        var name = request.Name.Trim();
+        if (name != title.Name)
+        {
+            if (title.IsSystem)
+                throw new DomainException(ErrorCodes.ExpenseSystemRowReadOnly, $"'{title.Name}' is a built-in title and cannot be renamed.", 409);
+            await EnsureTitleNameIsUniqueAsync(title.ExpenseCategoryId, name, excludingTitleId: expenseTitleId, ct);
+            title.Name = name;
+        }
+
+        // The GL code is editable on system rows too — the seeded codes are placeholders.
+        // Already-posted expenses keep the code they snapshotted at post time.
+        title.GlExpenseAccountCode = request.GlExpenseAccountCode.Trim();
+        title.Status = request.Status;
+        title.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+
+        return Map(title);
+    }
+
+    private async Task EnsureTitleNameIsUniqueAsync(int expenseCategoryId, string name, int? excludingTitleId, CancellationToken ct)
+    {
+        var duplicate = await _titles.Query().AnyAsync(t =>
+            t.ExpenseCategoryId == expenseCategoryId && t.Name == name
+            && (excludingTitleId == null || t.ExpenseTitleId != excludingTitleId), ct);
+        if (duplicate)
+            throw new DomainException(ErrorCodes.DuplicateExpenseTitle, $"A title named '{name}' already exists in this category.", 409);
+    }
+
+    private static ExpenseCategoryDto Map(ExpenseCategory c, bool includeInactive) => new(
+        c.ExpenseCategoryId, c.Code, c.Name, c.IsSystem, c.Status, c.SortOrder,
+        c.Titles
+            .Where(t => includeInactive || t.Status == EntityStatus.Active)
+            .OrderBy(t => t.SortOrder).ThenBy(t => t.Name)
+            .Select(Map).ToList());
+
+    private static ExpenseTitleDto Map(ExpenseTitle t) => new(
+        t.ExpenseTitleId, t.ExpenseCategoryId, t.Name, t.GlExpenseAccountCode, t.IsSystem, t.Status, t.SortOrder);
+}
diff --git a/Backend/ERPCore/Services/GrnService.cs b/Backend/ERPCore/Services/GrnService.cs
index 570a994..4e8bf23 100644
--- a/Backend/ERPCore/Services/GrnService.cs
+++ b/Backend/ERPCore/Services/GrnService.cs
@@ -34,6 +34,9 @@ public sealed class GrnService : IGrnService
     private readonly IRepository<Bin> _bins;
     private readonly IRepository<Vendor> _vendors;
     private readonly IRepository<Batch> _batches;
+    private readonly IRepository<Serial> _serials;
+    private readonly IRepository<SerialMovement> _serialMovements;
+    private readonly ISerialTrackingService _serialTracking;
     private readonly IRepository<StockLayer> _layers;
     private readonly IRepository<StockLedger> _ledger;
     private readonly IRepository<TaxRate> _taxRates;
@@ -50,7 +53,7 @@ public sealed class GrnService : IGrnService
     public GrnService(
         IRepository<Grn> grns, IRepository<PurchaseOrder> pos, IRepository<PoLine> poLines,
         IRepository<Item> items, IRepository<Warehouse> warehouses,
-        IRepository<Bin> bins, IRepository<Vendor> vendors, IRepository<Batch> batches,
+        IRepository<Bin> bins, IRepository<Vendor> vendors, IRepository<Batch> batches, IRepository<Serial> serials, IRepository<SerialMovement> serialMovements, ISerialTrackingService serialTracking,
         IRepository<StockLayer> layers, IRepository<StockLedger> ledger, IRepository<TaxRate> taxRates,
         IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser, IBranchConfigService branchConfig, IGrnConfigService grnConfig,
         IUnitOfWork uow, IGeneralLedgerService gl, INotificationService notifications, IGlAccountConfigService glAccounts)
@@ -63,6 +66,9 @@ public sealed class GrnService : IGrnService
         _bins = bins;
         _vendors = vendors;
         _batches = batches;
+        _serials = serials;
+        _serialMovements = serialMovements;
+        _serialTracking = serialTracking;
         _layers = layers;
         _ledger = ledger;
         _taxRates = taxRates;
@@ -110,6 +116,8 @@ public sealed class GrnService : IGrnService
     {
         var grn = await _grns.Query().AsNoTracking()
             .Include(g => g.Lines).ThenInclude(l => l.WarrantyNumbers)
+            .Include(g => g.Lines).ThenInclude(l => l.Serials)
+            .Include(g => g.Lines).ThenInclude(l => l.Batch)
             .Include(g => g.PurchaseInvoice)
             .FirstOrDefaultAsync(g => g.GrnId == grnId, ct);
         return grn is null ? null : Map(grn);
@@ -155,6 +163,7 @@ public sealed class GrnService : IGrnService
 
         var lines = new List<GrnLine>();
         var batchCache = new Dictionary<(int ItemId, string BatchNo), Batch>();
+        var requestSerials = new HashSet<(int ItemId, string SerialNo)>();
 
         foreach (var input in request.Lines)
         {
@@ -203,7 +212,9 @@ public sealed class GrnService : IGrnService
             var vatAmount = Math.Round(receivedValue * vatPct / 100m, 4, MidpointRounding.AwayFromZero);
 
             var batch = await ResolveBatchAsync(item, input.Batch, batchCache, ct);
-            var warrantyNumbers = ResolveWarrantyNumbers(item, input.WarrantyNumbers, input.Qty);
+            var warrantyNumbers = ResolveWarrantyNumbers(item, input.WarrantyNumbers, input.Qty,
+                serialTracked: await _serialTracking.IsSerialTrackedAsync(item, ct));
+            var serials = await ResolveSerialNumbersAsync(item, input.SerialNumbers, input.Qty, requestSerials, ct);
 
             lines.Add(new GrnLine
             {
@@ -221,7 +232,8 @@ public sealed class GrnService : IGrnService
                 ReceivedValue = receivedValue,
                 LineTotal = receivedValue + vatAmount,
                 HoldStatus = input.HoldStatus,
-                WarrantyNumbers = warrantyNumbers
+                WarrantyNumbers = warrantyNumbers,
+                Serials = serials
             });
         }
 
@@ -252,7 +264,7 @@ public sealed class GrnService : IGrnService
     public async Task<GrnConfirmResultDto> ConfirmAsync(int grnId, string? idempotencyKey, CancellationToken ct = default)
     {
         var grn = await _grns.Query()
-            .Include(g => g.Lines)
+            .Include(g => g.Lines).ThenInclude(l => l.Serials)
             .FirstOrDefaultAsync(g => g.GrnId == grnId, ct)
             ?? throw new NotFoundException($"GRN {grnId} was not found.");
 
@@ -278,10 +290,21 @@ public sealed class GrnService : IGrnService
                 var qtyBase = line.Qty;
                 var unitCostBase = line.NetUnitCost;
 
-                var layer = await _fifo.CreateInboundLayerAsync(
-                    line.ItemId, grn.WarehouseId, line.BatchId, null, line.GrnLineId,
-                    qtyBase, unitCostBase, now, token);
-                createdLayers.Add(layer);
+                if (line.Serials.Count > 0)
+                {
+                    // Serial-tracked: one Serial and one qty-1 layer per unit, so a sale can later
+                    // consume exactly the serial it names. The ledger stays one row per line
+                    // (below): every ledger row also posts a GL entry, and per-unit rows would mean
+                    // one GL call per serial — serial history is read from the document tables.
+                    createdLayers.AddRange(await ReceiveSerialsAsync(grn, line, unitCostBase, now, token));
+                }
+                else
+                {
+                    var layer = await _fifo.CreateInboundLayerAsync(
+                        line.ItemId, grn.WarehouseId, line.BatchId, null, line.GrnLineId,
+                        qtyBase, unitCostBase, now, token);
+                    createdLayers.Add(layer);
+                }
 
                 var key = (line.ItemId, grn.WarehouseId);
                 if (!runningBalance.TryGetValue(key, out var bal))
@@ -411,12 +434,16 @@ public sealed class GrnService : IGrnService
     /// period is not entered at receipt; it is snapshotted from <see cref="Item.WarrantyPeriodMonths"/>,
     /// which the item must have been given at creation (<see cref="ItemService"/> enforces that).
     /// </summary>
-    private static List<GrnLineWarrantyNumber> ResolveWarrantyNumbers(Item item, List<string>? numbers, decimal qty)
+    private static List<GrnLineWarrantyNumber> ResolveWarrantyNumbers(Item item, List<string>? numbers, decimal qty, bool serialTracked)
     {
         if (item.Warranty != Warranty.Warranty) return new List<GrnLineWarrantyNumber>();
         if (item.WarrantyPeriodMonths is null)
             throw new DomainException(
                 ErrorCodes.Validation, $"Item {item.Sku} is under warranty but has no warranty period configured.", 422);
+        // A serial item's serial number is its warranty identity (docs/ITEM_TRACKING_PLAN.md D1);
+        // its coverage is snapshotted onto each Serial at confirm instead. With serial numbers
+        // switched off the item has no serials, so it takes warranty numbers like any other.
+        if (serialTracked) return new List<GrnLineWarrantyNumber>();
 
         var trimmed = (numbers ?? new List<string>()).Select(n => n.Trim()).Where(n => n.Length > 0).ToList();
         if (trimmed.Count != qty)
@@ -429,6 +456,88 @@ public sealed class GrnService : IGrnService
         return trimmed.Select(n => new GrnLineWarrantyNumber { WarrantyNo = n, WarrantyPeriodMonths = item.WarrantyPeriodMonths.Value }).ToList();
     }
 
+    /// <summary>
+    /// A serial-tracked item requires exactly one serial number per received unit — so the
+    /// quantity must be whole. Numbers must be unique within the request and must not already
+    /// exist for the item. Any other item must not carry serial numbers.
+    /// </summary>
+    private async Task<List<GrnLineSerial>> ResolveSerialNumbersAsync(
+        Item item, List<string>? numbers, decimal qty, HashSet<(int, string)> requestSerials, CancellationToken ct)
+    {
+        var trimmed = (numbers ?? new List<string>()).Select(n => n.Trim()).Where(n => n.Length > 0).ToList();
+        if (!await _serialTracking.IsSerialTrackedAsync(item, ct))
+        {
+            _serialTracking.RejectSerialsWhileDisabled(item, trimmed.Count);
+            if (trimmed.Count > 0)
+                throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is not serial-tracked; serial numbers are not accepted.", 422);
+            return new List<GrnLineSerial>();
+        }
+
+        if (qty != decimal.Truncate(qty))
+            throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is serial-tracked; the quantity must be a whole number.", 422);
+        if (trimmed.Count != qty)
+            throw new DomainException(ErrorCodes.TrackingRequired,
+                $"Item {item.Sku} is serial-tracked; provide exactly {qty} serial number(s), got {trimmed.Count}.", 422);
+        if (trimmed.Any(n => n.Length > 100))
+            throw new DomainException(ErrorCodes.Validation, "A serial number cannot be longer than 100 characters.", 422);
+
+        // Case-insensitive, matching the utf8mb4_unicode_ci unique index on serials (ItemId, SerialNo).
+        foreach (var n in trimmed)
+            if (!requestSerials.Add((item.ItemId, n.ToUpperInvariant())))
+                throw new DomainException(ErrorCodes.SerialDuplicate, $"Serial number {n} for item {item.Sku} is entered more than once.", 422);
+
+        await EnsureSerialsFreeAsync(item.ItemId, item.Sku, trimmed, ct);
+        return trimmed.Select(n => new GrnLineSerial { SerialNo = n }).ToList();
+    }
+
+    private async Task EnsureSerialsFreeAsync(int itemId, string sku, List<string> numbers, CancellationToken ct)
+    {
+        var taken = await _serials.Query().AsNoTracking()
+            .Where(s => s.ItemId == itemId && numbers.Contains(s.SerialNo))
+            .Select(s => s.SerialNo).Take(5).ToListAsync(ct);
+        if (taken.Count > 0)
+            throw new DomainException(ErrorCodes.SerialDuplicate,
+                $"Serial number(s) already exist for item {sku}: {string.Join(", ", taken)}.", 409);
+    }
+
+    /// <summary>
+    /// Confirm-time half of serial capture: re-checks the numbers are still free (another GRN
+    /// may have confirmed them since this draft was created — the unique index is the final
+    /// guard), then creates each <see cref="Serial"/> with its own qty-1 FIFO layer.
+    /// </summary>
+    private async Task<List<StockLayer>> ReceiveSerialsAsync(Grn grn, GrnLine line, decimal unitCost, DateTime now, CancellationToken ct)
+    {
+        var item = await _items.Query().AsNoTracking().FirstAsync(i => i.ItemId == line.ItemId, ct);
+        await EnsureSerialsFreeAsync(item.ItemId, item.Sku, line.Serials.Select(s => s.SerialNo).ToList(), ct);
+
+        var warrantyMonths = item.Warranty == Warranty.Warranty ? item.WarrantyPeriodMonths : null;
+        var layers = new List<StockLayer>();
+        foreach (var captured in line.Serials.OrderBy(s => s.GrnLineSerialId))
+        {
+            var serial = new Serial
+            {
+                ItemId = line.ItemId,
+                SerialNo = captured.SerialNo,
+                Status = SerialStatus.InStock,
+                WarehouseId = grn.WarehouseId,
+                BinId = line.BinId,
+                GrnLineId = line.GrnLineId,
+                ReceivedAt = now,
+                CreatedAt = now,
+                WarrantyPeriodMonths = warrantyMonths
+            };
+            await _serials.AddAsync(serial, ct);
+            captured.Serial = serial; // FK fixed up on SaveChanges
+            await _serialMovements.AddAsync(SerialMovement.Of(serial, null, DocumentTypes.Grn, grn.GrnId, _currentUser.AuditUserId, now), ct);
+
+            var layer = await _fifo.CreateInboundLayerAsync(
+                line.ItemId, grn.WarehouseId, line.BatchId, null, line.GrnLineId, 1m, unitCost, now, ct);
+            layer.Serial = serial;
+            layers.Add(layer);
+        }
+        return layers;
+    }
+
     private async Task UpdatePoStatusAsync(int? poId, CancellationToken ct)
     {
         if (poId is null) return;
@@ -472,5 +581,7 @@ public sealed class GrnService : IGrnService
             l.DiscountPct, l.NetUnitCost, l.VatPct, l.VatAmount, l.ReceivedValue, l.LineTotal,
             l.PoUnitPrice is null ? 0m : Math.Round((l.UnitCost - l.PoUnitPrice.Value) * l.Qty, 4, MidpointRounding.AwayFromZero),
             l.HoldStatus, l.BatchId,
-            l.WarrantyNumbers.Select(w => new GrnLineWarrantyNumberDto(w.WarrantyNo, w.WarrantyPeriodMonths)).ToList())).ToList());
+            l.WarrantyNumbers.Select(w => new GrnLineWarrantyNumberDto(w.WarrantyNo, w.WarrantyPeriodMonths)).ToList(),
+            l.Batch?.BatchNo, l.Batch?.ExpiryDate,
+            l.Serials.OrderBy(s => s.GrnLineSerialId).Select(s => new GrnLineSerialDto(s.SerialNo, s.SerialId)).ToList())).ToList());
 }
diff --git a/Backend/ERPCore/Services/Interfaces/IAdjustmentService.cs b/Backend/ERPCore/Services/Interfaces/IAdjustmentService.cs
index 60db2bb..51693a0 100644
--- a/Backend/ERPCore/Services/Interfaces/IAdjustmentService.cs
+++ b/Backend/ERPCore/Services/Interfaces/IAdjustmentService.cs
@@ -1,15 +1,25 @@
+using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Stock;
 
 namespace ERPCore.Services.Interfaces;
 
-/// <summary>Stock-adjustment business logic (docs/11 §5.5; FR-STK-07; 02-SECURITY C.5).</summary>
+/// <summary>Stock-adjustment business logic (docs/11 §5.5; FR-STK-07; 02-SECURITY C.5; docs/DUAL_APPROVAL_PLAN.md §5).</summary>
 public interface IAdjustmentService
 {
     Task<PagedResponse<AdjustmentSummaryDto>> ListAsync(
-        PageQuery query, int? warehouseId, int? branchId, int? reasonCodeId, CancellationToken ct = default);
+        PageQuery query, int? warehouseId, int? branchId, int? reasonCodeId, AdjustmentStatus? status = null, CancellationToken ct = default);
 
     Task<AdjustmentDto?> GetAsync(int adjustmentId, CancellationToken ct = default);
 
+    /// <summary>Submits an adjustment request — it posts at once only when approvals are switched off.</summary>
     Task<AdjustmentDto> CreateAsync(CreateAdjustmentRequest request, CancellationToken ct = default);
+
+    /// <summary>Gives the next approval; the last one posts the stock movement and GL.</summary>
+    Task<AdjustmentDto> ApproveAsync(int adjustmentId, string? comment, CancellationToken ct = default);
+
+    Task<AdjustmentDto> RejectAsync(int adjustmentId, string reason, CancellationToken ct = default);
+
+    /// <summary>The requester withdraws a request that is still pending.</summary>
+    Task<AdjustmentDto> CancelAsync(int adjustmentId, CancellationToken ct = default);
 }
diff --git a/Backend/ERPCore/Services/Interfaces/IApprovalService.cs b/Backend/ERPCore/Services/Interfaces/IApprovalService.cs
new file mode 100644
index 0000000..2901a43
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/IApprovalService.cs
@@ -0,0 +1,48 @@
+using ERPCore.Dtos.Approvals;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>Where a document stands in its approval, as the shared engine needs to see it.</summary>
+/// <param name="NavCode">The screen whose Approve action an approver needs (e.g. <c>stock.adjustments</c>).</param>
+/// <param name="CurrentLevel">The approval being given now: 1, or 2 after the first.</param>
+public sealed record ApprovalTarget(
+    string DocType, int DocId, string DocNo, string NavCode, int RequestedBy, int RequiredApprovals, int CurrentLevel, int? Level1ApprovedBy);
+
+public enum ApprovalOutcome
+{
+    AdvancedToLevel2,
+    FullyApproved,
+    Rejected
+}
+
+/// <summary>
+/// The shared maker–checker rules for stock and price adjustments (docs/DUAL_APPROVAL_PLAN.md §4):
+/// the requester can't approve, the two approvers must differ, level 2 may be limited to roles.
+/// The Approve permission itself is checked by the endpoint's policy. Decisions are added to the
+/// caller's unit of work — the document service saves them with its own changes.
+/// </summary>
+public interface IApprovalService
+{
+    Task<ApprovalConfigDto> GetConfigAsync(CancellationToken ct = default);
+    Task<ApprovalConfigDto> UpdateConfigAsync(UpdateApprovalConfigRequest request, CancellationToken ct = default);
+
+    /// <summary>Approvals a stock adjustment worth <paramref name="absoluteValue"/> needs (0, 1 or 2).</summary>
+    Task<int> RequiredForStockAdjustmentAsync(decimal absoluteValue, CancellationToken ct = default);
+
+    /// <summary>Approvals a price change of <paramref name="largestChangePercent"/> needs (0, 1 or 2).</summary>
+    Task<int> RequiredForPriceAdjustmentAsync(decimal largestChangePercent, CancellationToken ct = default);
+
+    /// <summary>Validates the current user may decide, and records the decision (unsaved).</summary>
+    Task<ApprovalOutcome> DecideAsync(ApprovalTarget target, bool approve, string? comment, CancellationToken ct = default);
+
+    /// <summary>Null when the current user may decide; otherwise the reason they can't.</summary>
+    Task<string?> WhyCannotDecideAsync(ApprovalTarget target, CancellationToken ct = default);
+
+    Task<IReadOnlyList<ApprovalStepDto>> HistoryAsync(string docType, int docId, CancellationToken ct = default);
+
+    /// <summary>Active users who could give <paramref name="target"/>'s current approval — for notifications.</summary>
+    Task<IReadOnlyList<int>> ApproverIdsAsync(ApprovalTarget target, CancellationToken ct = default);
+
+    /// <summary>Notifies whoever can give the target's next approval that it is waiting.</summary>
+    Task NotifyPendingAsync(ApprovalTarget target, string summary, CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/IBankDepositServices.cs b/Backend/ERPCore/Services/Interfaces/IBankDepositServices.cs
new file mode 100644
index 0000000..89f9975
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/IBankDepositServices.cs
@@ -0,0 +1,40 @@
+using ERPCore.Dtos.Accounts;
+using ERPCore.Dtos.Common;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>
+/// Till cash in hand per branch and business day (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.1) — the one
+/// calculation both the deposit form and the Day-End Sales Report read. A branch-scoped caller
+/// always gets their own branch; <c>branchId</c> null means every branch together.
+/// </summary>
+public interface ICashInHandService
+{
+    /// <summary>The configured <c>BankDeposit:CashTrackingStartDate</c>, if any.</summary>
+    DateOnly? TrackingStartDate { get; }
+
+    /// <summary><paramref name="day"/> null ⇒ today in the business time zone.</summary>
+    Task<CashInHandDto> GetPositionAsync(DateOnly? day, int? branchId, CancellationToken ct = default);
+
+    /// <summary>Every day of <c>from</c>..<c>to</c> (at most 92 days), opening carried in from earlier days.</summary>
+    Task<CashInHandDailyDto> GetDailyAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct = default);
+
+    /// <summary>Same as <see cref="GetDailyAsync"/> without the range cap — for callers that validate their own range.</summary>
+    Task<IReadOnlyList<CashPositionDto>> GetRangeAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct = default);
+
+    /// <summary>
+    /// The most that can still be deposited against <paramref name="day"/>: the lowest closing balance
+    /// from that day to today, never below zero; zero for a future day or one before tracking starts.
+    /// <paramref name="branchScope"/> is used as given (the caller has already resolved it).
+    /// </summary>
+    Task<decimal> GetAvailableToDepositAsync(DateOnly day, int? branchScope, CancellationToken ct = default);
+}
+
+/// <summary>Bank deposits of till cash — record (posts GL), cancel (reverses GL), list (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.2).</summary>
+public interface IBankDepositService
+{
+    Task<BankDepositListDto> ListAsync(PageQuery query, BankDepositListFilter filter, CancellationToken ct = default);
+    Task<BankDepositDto?> GetAsync(int bankDepositId, CancellationToken ct = default);
+    Task<BankDepositDto> CreateAsync(CreateBankDepositRequest request, CancellationToken ct = default);
+    Task<BankDepositDto> CancelAsync(int bankDepositId, CancelBankDepositRequest request, CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/IDayEndReportService.cs b/Backend/ERPCore/Services/Interfaces/IDayEndReportService.cs
new file mode 100644
index 0000000..e657340
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/IDayEndReportService.cs
@@ -0,0 +1,11 @@
+using ERPCore.Dtos.Reports;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>Read-only day-end sales/expense/income report (docs/DAY_END_SALES_REPORT_PLAN.md §4).</summary>
+public interface IDayEndReportService
+{
+    /// <summary><paramref name="date"/> null ⇒ today in the report's time zone.</summary>
+    Task<DayEndReportDto> GetDayAsync(DateOnly? date, int? branchId, CancellationToken ct = default);
+    Task<DayEndDailyReportDto> GetDailyAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/IExpenseServices.cs b/Backend/ERPCore/Services/Interfaces/IExpenseServices.cs
new file mode 100644
index 0000000..dc4e8a1
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/IExpenseServices.cs
@@ -0,0 +1,35 @@
+using ERPCore.Common.Http;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Expenses;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>Expense categories and their titles (docs/EXPENSE_MODULE_PLAN.md §2.1).</summary>
+public interface IExpenseSetupService
+{
+    Task<IReadOnlyList<ExpenseCategoryDto>> ListAsync(bool includeInactive, CancellationToken ct = default);
+    Task<ExpenseCategoryDto> UpdateCategoryAsync(int expenseCategoryId, UpdateExpenseCategoryRequest request, CancellationToken ct = default);
+    Task<ExpenseTitleDto> CreateTitleAsync(int expenseCategoryId, CreateExpenseTitleRequest request, CancellationToken ct = default);
+    Task<ExpenseTitleDto> UpdateTitleAsync(int expenseTitleId, UpdateExpenseTitleRequest request, CancellationToken ct = default);
+}
+
+/// <summary>Expense bills: draft CRUD, post (GL accrual), cancel and reporting (docs/EXPENSE_MODULE_PLAN.md §4).</summary>
+public interface IExpenseService
+{
+    Task<PagedResponse<ExpenseSummaryDto>> ListAsync(PageQuery query, ExpenseListFilter filter, CancellationToken ct = default);
+    Task<ETagged<ExpenseDto>?> GetAsync(int expenseId, CancellationToken ct = default);
+    Task<ETagged<ExpenseDto>> CreateAsync(CreateExpenseRequest request, CancellationToken ct = default);
+    Task<ETagged<ExpenseDto>> UpdateAsync(int expenseId, UpdateExpenseRequest request, uint expectedRowVersion, CancellationToken ct = default);
+    Task DeleteAsync(int expenseId, CancellationToken ct = default);
+    Task<ExpenseDto> PostAsync(int expenseId, CancellationToken ct = default);
+    Task<ExpenseDto> CancelAsync(int expenseId, CancelExpenseRequest request, CancellationToken ct = default);
+    Task<ExpenseSummaryReportDto> GetSummaryAsync(DateOnly? from, DateOnly? to, CancellationToken ct = default);
+}
+
+/// <summary>Payments against a Posted expense's balance, and the one-step Post &amp; Pay.</summary>
+public interface IExpensePaymentService
+{
+    Task<IReadOnlyList<ExpensePaymentDto>> PayAsync(int expenseId, CreateExpensePaymentRequest request, CancellationToken ct = default);
+    Task<ExpenseDto> PostAndPayAsync(int expenseId, CreateExpensePaymentRequest request, CancellationToken ct = default);
+    Task<IReadOnlyList<ExpensePaymentDto>> ListAsync(int expenseId, CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs b/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs
index ac7e043..be04655 100644
--- a/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs
+++ b/Backend/ERPCore/Services/Interfaces/IFifoCostingService.cs
@@ -31,9 +31,26 @@ public interface IFifoCostingService
     /// Sales only (Sales Configuration "Allow selling beyond stock"): instead of throwing, the
     /// quantity stock can't cover is recorded as a negative layer at the last known unit cost.
     /// </param>
+    /// <param name="serialIds">
+    /// Serial-tracked issue: consume exactly these serials' qty-1 layers (count must equal
+    /// <paramref name="qtyBase"/>), or throw <c>SERIAL_NOT_AVAILABLE</c>. When null, serial layers
+    /// are never touched — serial stock only leaves by naming its serial — so only untracked
+    /// (legacy, pre-serial-capture) layers are issued. Shortfall is never allowed with serials.
+    /// </param>
+    /// <remarks>
+    /// Issue order is FEFO then FIFO: layers whose batch expires soonest go first, then oldest
+    /// receipt. Items without batches therefore keep plain FIFO.
+    /// </remarks>
     Task<IReadOnlyList<ConsumedSegment>> ConsumeAsync(
         int itemId, int warehouseId, int? batchId, decimal qtyBase, CancellationToken ct = default,
-        bool allowShortfall = false);
+        bool allowShortfall = false, IReadOnlyCollection<int>? serialIds = null);
+
+    /// <summary>
+    /// Read-only (no locks) FEFO preview of how <paramref name="qtyBase"/> would be issued across
+    /// batches — for UI suggestions. Expired, on-hold and serial layers are excluded.
+    /// </summary>
+    Task<IReadOnlyList<BatchAllocation>> SuggestBatchesAsync(
+        int itemId, int warehouseId, decimal qtyBase, CancellationToken ct = default);
 
     /// <summary>
     /// Append an immutable ledger entry. Value defaults to <c>round(qtyBase × unitCost, 4)</c>.
@@ -60,4 +77,7 @@ public interface IFifoCostingService
 }
 
 /// <summary>A quantity consumed from one FIFO layer at that layer's unit cost.</summary>
-public sealed record ConsumedSegment(int LayerId, decimal Qty, decimal UnitCost);
+public sealed record ConsumedSegment(int LayerId, decimal Qty, decimal UnitCost, int? BatchId = null, int? SerialId = null);
+
+/// <summary>A suggested batch pick: <see cref="Qty"/> of <see cref="BatchId"/> (null = unbatched stock).</summary>
+public sealed record BatchAllocation(int? BatchId, string? BatchNo, DateOnly? ExpiryDate, decimal Qty);
diff --git a/Backend/ERPCore/Services/Interfaces/IItemService.cs b/Backend/ERPCore/Services/Interfaces/IItemService.cs
index 48e01c7..1020570 100644
--- a/Backend/ERPCore/Services/Interfaces/IItemService.cs
+++ b/Backend/ERPCore/Services/Interfaces/IItemService.cs
@@ -34,5 +34,8 @@ public interface IItemService
 
     /// <summary>Barcode/RFID scan lookup — item barcode/SKU, or a batch/serial barcode/no
     /// (optionally scoped to <paramref name="itemId"/> first). Null when nothing matches.</summary>
+    /// <summary>The item's most recent posted GRN receipts (newest first) — what it was bought at.</summary>
+    Task<IReadOnlyList<ItemPurchasePriceDto>> GetPurchasePricesAsync(int itemId, int take = 5, CancellationToken ct = default);
+
     Task<ItemScanResultDto?> ScanAsync(string code, int? itemId, CancellationToken ct = default);
 }
diff --git a/Backend/ERPCore/Services/Interfaces/IItemTrackingService.cs b/Backend/ERPCore/Services/Interfaces/IItemTrackingService.cs
new file mode 100644
index 0000000..9d9b32c
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/IItemTrackingService.cs
@@ -0,0 +1,46 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Stock;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>Read side of item tracking: pickers, serial and warranty registers, batch stock.</summary>
+public interface IItemTrackingService
+{
+    /// <summary>
+    /// The next <paramref name="count"/> free serial numbers for an item under
+    /// <paramref name="prefix"/>: continues after the highest number already used with that
+    /// prefix (received serials and numbers on draft GRNs), zero-padded to at least 4 digits —
+    /// e.g. prefix "PH-" after PH-0041 gives PH-0042, PH-0043, …
+    /// </summary>
+    Task<IReadOnlyList<string>> NextSerialNumbersAsync(int itemId, string prefix, int count, CancellationToken ct = default);
+
+    /// <summary>In-stock serials of an item at a warehouse, optionally filtered by number.</summary>
+    Task<IReadOnlyList<AvailableSerialDto>> GetAvailableSerialsAsync(int itemId, int warehouseId, string? q, int take, CancellationToken ct = default);
+
+    /// <summary>Issuable (not expired, not on hold) stock per batch, soonest expiry first.</summary>
+    Task<IReadOnlyList<AvailableBatchDto>> GetAvailableBatchesAsync(int itemId, int warehouseId, CancellationToken ct = default);
+
+    /// <summary>How posting would pick <paramref name="qty"/> FEFO across batches.</summary>
+    Task<IReadOnlyList<BatchSuggestionDto>> SuggestBatchesAsync(int itemId, int warehouseId, decimal qty, CancellationToken ct = default);
+
+    Task<PagedResponse<SerialSummaryDto>> ListSerialsAsync(
+        PageQuery query, int? itemId, int? warehouseId, SerialStatus? status, CancellationToken ct = default);
+
+    Task<SerialDetailDto?> GetSerialAsync(int serialId, CancellationToken ct = default);
+
+    /// <summary>Exact serial-number lookup (all items) — e.g. a warranty desk scanning a unit.</summary>
+    Task<IReadOnlyList<SerialDetailDto>> FindSerialAsync(string serialNo, CancellationToken ct = default);
+
+    /// <summary>
+    /// Warranty register. <paramref name="expiringWithinDays"/> keeps active warranties ending within
+    /// that many days; <paramref name="expired"/> true/false keeps only expired / unexpired ones.
+    /// </summary>
+    Task<PagedResponse<WarrantyRegistrationDto>> ListWarrantiesAsync(
+        PageQuery query, int? customerId, int? itemId, string? serialNo, WarrantyStatus? status,
+        int? expiringWithinDays, bool? expired, CancellationToken ct = default);
+
+    /// <summary>Batch stock on hand (positive), optionally only batches expiring within N days (expired included).</summary>
+    Task<PagedResponse<BatchStockDto>> ListBatchStockAsync(
+        PageQuery query, int? itemId, int? warehouseId, int? expiringWithinDays, CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/INotificationService.cs b/Backend/ERPCore/Services/Interfaces/INotificationService.cs
index 1b84875..7c0da2d 100644
--- a/Backend/ERPCore/Services/Interfaces/INotificationService.cs
+++ b/Backend/ERPCore/Services/Interfaces/INotificationService.cs
@@ -17,6 +17,19 @@ public interface INotificationService
         int? relatedEntityId = null,
         CancellationToken ct = default);
 
+    /// <summary>
+    /// Same as <see cref="RaiseAsync"/> but delivered only to <paramref name="userIds"/> (active ones) —
+    /// e.g. the approvers of a request, or its requester. Same InApp-channel gate; no-op for an empty list.
+    /// </summary>
+    Task NotifyUsersAsync(
+        IEnumerable<int> userIds,
+        string moduleKey,
+        string title,
+        string message,
+        string? relatedEntityType = null,
+        int? relatedEntityId = null,
+        CancellationToken ct = default);
+
     Task<NotificationFeedDto> GetFeedAsync(int userId, int take = 20, CancellationToken ct = default);
 
     Task MarkAllReadAsync(int userId, CancellationToken ct = default);
diff --git a/Backend/ERPCore/Services/Interfaces/IPriceAdjustmentService.cs b/Backend/ERPCore/Services/Interfaces/IPriceAdjustmentService.cs
new file mode 100644
index 0000000..0e7d18f
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/IPriceAdjustmentService.cs
@@ -0,0 +1,25 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Products;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>Selling-price change requests with dual approval (docs/DUAL_APPROVAL_PLAN.md §6).</summary>
+public interface IPriceAdjustmentService
+{
+    Task<PagedResponse<PriceAdjustmentSummaryDto>> ListAsync(PageQuery query, PriceAdjustmentStatus? status, int? itemId, CancellationToken ct = default);
+    Task<PriceAdjustmentDto?> GetAsync(int priceAdjustmentId, CancellationToken ct = default);
+
+    /// <summary>Submits a request — applied at once only when price approvals are switched off.</summary>
+    Task<PriceAdjustmentDto> CreateAsync(CreatePriceAdjustmentRequest request, CancellationToken ct = default);
+
+    /// <summary>Gives the next approval; the last one writes the new prices to the items.</summary>
+    Task<PriceAdjustmentDto> ApproveAsync(int priceAdjustmentId, string? comment, CancellationToken ct = default);
+    Task<PriceAdjustmentDto> RejectAsync(int priceAdjustmentId, string reason, CancellationToken ct = default);
+    Task<PriceAdjustmentDto> CancelAsync(int priceAdjustmentId, CancellationToken ct = default);
+
+    Task<IReadOnlyList<ItemPriceHistoryDto>> ItemHistoryAsync(int itemId, CancellationToken ct = default);
+
+    /// <summary>True when selling prices may only change through an approved price adjustment.</summary>
+    Task<bool> PricesNeedApprovalAsync(CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/ISalesDomainService.cs b/Backend/ERPCore/Services/Interfaces/ISalesDomainService.cs
index 2344e57..0f41825 100644
--- a/Backend/ERPCore/Services/Interfaces/ISalesDomainService.cs
+++ b/Backend/ERPCore/Services/Interfaces/ISalesDomainService.cs
@@ -1,3 +1,4 @@
+using ERPCore.Domain.Entities;
 using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Sales;
 
@@ -63,6 +64,18 @@ public interface ISalesDomainService
         bool isFreeIssue);
 
     Task<bool> IsStockedItemAsync(int itemId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Batch/serial rules for one sales line (docs/ITEM_TRACKING_PLAN.md Phase 4). A serial-tracked
+    /// item needs one serial per unit of <paramref name="totalQty"/>, each InStock at
+    /// <paramref name="warehouseId"/> and not already used on another line of the same document
+    /// (<paramref name="documentSerials"/>) — unless enough pre-tracking (serial-less) stock is
+    /// still on hand there (D6). A pinned batch must belong to the item and not be expired.
+    /// Returns the chosen serials as tracked entities, for the line's serial rows.
+    /// </summary>
+    Task<IReadOnlyList<Serial>> ValidateLineTrackingAsync(
+        int itemId, int warehouseId, decimal totalQty, int? batchId, IReadOnlyCollection<int>? serialIds,
+        ISet<int> documentSerials, CancellationToken ct = default);
 }
 
 public sealed record SalesLineComputation(
diff --git a/Backend/ERPCore/Services/Interfaces/ISerialTrackingService.cs b/Backend/ERPCore/Services/Interfaces/ISerialTrackingService.cs
new file mode 100644
index 0000000..20ac2bf
--- /dev/null
+++ b/Backend/ERPCore/Services/Interfaces/ISerialTrackingService.cs
@@ -0,0 +1,55 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Services.Interfaces;
+
+/// <summary>
+/// Shared serial rules for stock documents other than GRN and sales — purchase returns,
+/// transfers, adjustments and counts (docs/ITEM_TRACKING_PLAN.md Phases 6–7). Validation is
+/// done before the document's transaction; <see cref="MoveAsync"/> runs inside it.
+/// </summary>
+public interface ISerialTrackingService
+{
+    /// <summary>
+    /// Product Configuration "Serial numbers" switch (<see cref="ProductConfig.SerialNumbersEnabled"/>).
+    /// Off: no document asks for or accepts serials, and serial-mode items are handled as
+    /// untracked stock. Defaults to on when the config row is missing.
+    /// </summary>
+    Task<bool> IsEnabledAsync(CancellationToken ct = default);
+
+    /// <summary>True when <paramref name="item"/> is serial-tracked and the switch is on.</summary>
+    Task<bool> IsSerialTrackedAsync(Item item, CancellationToken ct = default);
+
+    /// <summary>
+    /// Throws <c>CONFIG_DISABLED</c> when serials were sent for a serial-mode item while the switch
+    /// is off — they are refused rather than silently dropped.
+    /// </summary>
+    void RejectSerialsWhileDisabled(Item item, int serialCount);
+
+    /// <summary>
+    /// Serials leaving <paramref name="warehouseId"/>. For a serial-tracked item: one per unit of
+    /// <paramref name="qty"/>, each currently at that warehouse in one of
+    /// <paramref name="allowedStatuses"/> and not used elsewhere on the same document
+    /// (<paramref name="documentSerials"/>); with none named, only pre-tracking (serial-less)
+    /// stock may go (D6). Any other item must name none. Returns tracked entities.
+    /// </summary>
+    Task<IReadOnlyList<Serial>> ResolveOutboundAsync(
+        Item item, int warehouseId, decimal qty, IReadOnlyCollection<int>? serialIds,
+        ISet<int> documentSerials, IReadOnlyCollection<SerialStatus> allowedStatuses, CancellationToken ct = default);
+
+    /// <summary>
+    /// Serials arriving by adjustment or count: each number must be new for the item (it is
+    /// added to the context, unsaved and without a location — save before building
+    /// <see cref="StockDelta"/>s, which need its id) or an existing serial
+    /// that is not currently in stock anywhere (it is brought back). One per unit of
+    /// <paramref name="qty"/>; required for a serial-tracked item, rejected otherwise.
+    /// </summary>
+    Task<IReadOnlyList<Serial>> ResolveInboundAsync(
+        Item item, int warehouseId, decimal qty, IReadOnlyCollection<string>? serialNos,
+        ISet<string> documentSerialNos, CancellationToken ct = default);
+
+    /// <summary>Sets status and location on each serial and appends its <see cref="SerialMovement"/>.</summary>
+    Task MoveAsync(
+        IEnumerable<Serial> serials, SerialStatus status, int? warehouseId, int? binId,
+        string sourceDocType, int sourceDocId, DateTime now, CancellationToken ct = default);
+}
diff --git a/Backend/ERPCore/Services/Interfaces/IStockMutator.cs b/Backend/ERPCore/Services/Interfaces/IStockMutator.cs
index 1614d19..829f763 100644
--- a/Backend/ERPCore/Services/Interfaces/IStockMutator.cs
+++ b/Backend/ERPCore/Services/Interfaces/IStockMutator.cs
@@ -2,8 +2,16 @@ using ERPCore.Domain.Entities;
 
 namespace ERPCore.Services.Interfaces;
 
-/// <summary>A signed base-UOM change to an item's stock at one warehouse.</summary>
-public sealed record StockDelta(int ItemId, int? BinId, int? BatchId, decimal QtyDelta);
+/// <summary>
+/// A signed base-UOM change to an item's stock at one warehouse.
+/// <see cref="SerialIds"/> (serial-tracked items): an outbound delta consumes exactly those
+/// serials' layers; an inbound delta creates one qty-1 layer per serial. Either way the count
+/// must equal |<see cref="QtyDelta"/>|, and the caller owns the serials' status/location.
+/// <see cref="UnitCost"/> overrides the inbound cost (default: last cost at the warehouse).
+/// </summary>
+public sealed record StockDelta(
+    int ItemId, int? BinId, int? BatchId, decimal QtyDelta,
+    IReadOnlyList<int>? SerialIds = null, decimal? UnitCost = null);
 
 /// <summary>
 /// Shared poster for stock-affecting documents (adjustments, count variances,
diff --git a/Backend/ERPCore/Services/Interfaces/IVendorService.cs b/Backend/ERPCore/Services/Interfaces/IVendorService.cs
index bc78b41..75a3077 100644
--- a/Backend/ERPCore/Services/Interfaces/IVendorService.cs
+++ b/Backend/ERPCore/Services/Interfaces/IVendorService.cs
@@ -13,4 +13,5 @@ public interface IVendorService
     Task<ETagged<VendorDto>> CreateAsync(CreateVendorRequest request, CancellationToken ct = default);
     Task<ETagged<VendorDto>> UpdateAsync(int vendorId, UpdateVendorRequest request, uint expectedRowVersion, CancellationToken ct = default);
     Task SetStatusAsync(int vendorId, EntityStatus status, CancellationToken ct = default);
+    Task DeleteAsync(int vendorId, CancellationToken ct = default);
 }
diff --git a/Backend/ERPCore/Services/ItemService.cs b/Backend/ERPCore/Services/ItemService.cs
index a6d13b4..1058f7c 100644
--- a/Backend/ERPCore/Services/ItemService.cs
+++ b/Backend/ERPCore/Services/ItemService.cs
@@ -32,6 +32,12 @@ public sealed class ItemService : IItemService
     private readonly IRepository<Brand> _brands;
     private readonly IRepository<Uom> _uoms;
     private readonly IRepository<TaxRate> _taxRates;
+    private readonly IRepository<ApprovalConfig> _approvalConfig;
+
+    /// <summary>Price approvals on (the default) unless Settings → Approvals set price levels to 0.</summary>
+    private async Task<bool> PricesNeedApprovalAsync(CancellationToken ct)
+        => (await _approvalConfig.Query().AsNoTracking().Where(c => c.ApprovalConfigId == ApprovalConfig.SingletonId)
+               .Select(c => (int?)c.PriceAdjustmentLevels).FirstOrDefaultAsync(ct) ?? 2) > 0;
     private readonly IRepository<Vendor> _vendors;
     private readonly IRepository<Warehouse> _warehouses;
     private readonly IRepository<StockLayer> _stockLayers;
@@ -59,8 +65,10 @@ public sealed class ItemService : IItemService
         IRepository<Serial> serials,
         IProductConfigService config,
         INotificationService notifications,
-        IUnitOfWork uow)
+        IUnitOfWork uow,
+        IRepository<ApprovalConfig> approvalConfig)
     {
+        _approvalConfig = approvalConfig;
         _items = items;
         _categories = categories;
         _subCategories = subCategories;
@@ -207,6 +215,21 @@ public sealed class ItemService : IItemService
         return PagedResponse<ItemOverviewDto>.Create(rows, query.Page, query.PageSize, total);
     }
 
+    public async Task<IReadOnlyList<ItemPurchasePriceDto>> GetPurchasePricesAsync(int itemId, int take = 5, CancellationToken ct = default)
+    {
+        if (!await _items.Query().AnyAsync(i => i.ItemId == itemId, ct))
+            throw new NotFoundException($"Item {itemId} was not found.");
+
+        return await _grnLines.Query().AsNoTracking()
+            .Where(l => l.ItemId == itemId && l.Grn!.PostedAt != null)
+            .OrderByDescending(l => l.Grn!.PostedAt).ThenByDescending(l => l.GrnLineId)
+            .Take(Math.Clamp(take, 1, 50))
+            .Select(l => new ItemPurchasePriceDto(
+                l.GrnId, l.Grn!.DocNo, l.Grn.PostedAt!.Value, l.Grn.VendorId, l.Grn.Vendor!.Name, l.Grn.Warehouse!.Code,
+                l.Qty, l.UnitCost, l.DiscountPct, l.NetUnitCost, l.VatPct))
+            .ToListAsync(ct);
+    }
+
     public async Task<ETagged<ItemDetailDto>?> GetAsync(int itemId, CancellationToken ct = default)
     {
         var item = await _items.Query().AsNoTracking()
@@ -298,7 +321,7 @@ public sealed class ItemService : IItemService
         await ValidateReferencesAsync(
             request.CategoryId, request.SubCategoryId, request.BrandId,
             request.BaseUomId, request.DefaultVendorId, request.TaxRateId, config, ct);
-        ValidateFeatureConfiguration(request, config);
+        ValidateFeatureConfiguration(request, config, item.TrackingMode);
 
         // The base UOM is the sole meaning of every quantity recorded against this item —
         // stock layers, ledger rows and document lines are all plain counts of it. Once any
@@ -309,6 +332,15 @@ public sealed class ItemService : IItemService
                 ErrorCodes.MasterInUse,
                 $"Item {itemId} has stock history; its base UOM can no longer be changed.", 409);
 
+        // With price approvals on, selling prices change only through an approved price adjustment
+        // (docs/DUAL_APPROVAL_PLAN.md §6.3). Sending the current prices back unchanged is fine.
+        var pricesChanged = item.SellingMinPrice != request.SellingMinPrice
+            || item.SellingMaxPrice != request.SellingMaxPrice
+            || item.SellingFlatPrice != request.SellingFlatPrice;
+        if (pricesChanged && await PricesNeedApprovalAsync(ct))
+            throw new DomainException(ErrorCodes.PriceChangeRequiresApproval,
+                "Selling prices need approval — raise a price adjustment (Products → Price Adjustments) instead of editing them here.", 409);
+
         ItemContent.ValidatePair(request.ContentQty, request.ContentUnit);
         var (contentBaseQty, contentBaseUnit) = ItemContent.Normalize(request.ContentQty, request.ContentUnit);
         var warrantyPeriodMonths = ValidateWarrantyPeriod(
@@ -490,15 +522,20 @@ public sealed class ItemService : IItemService
             request.SellingMinPrice, request.SellingMaxPrice, request.SellingFlatPrice,
             request.TrackingMode, request.Warranty, config);
 
-    private static void ValidateFeatureConfiguration(UpdateItemRequest request, ProductConfigDto config)
+    /// <summary>
+    /// An item keeps the tracking mode it already has even after that feature is switched off —
+    /// otherwise it could not be edited at all; only a change <em>to</em> a disabled mode is refused.
+    /// </summary>
+    private static void ValidateFeatureConfiguration(UpdateItemRequest request, ProductConfigDto config, TrackingMode currentTrackingMode)
         => ValidateFeatureConfiguration(
             request.SellingMinPrice, request.SellingMaxPrice, request.SellingFlatPrice,
-            request.TrackingMode, request.Warranty, config);
+            request.TrackingMode, request.Warranty, config, currentTrackingMode);
 
     private static void ValidateFeatureConfiguration(
         decimal? sellingMinPrice, decimal? sellingMaxPrice, decimal? sellingFlatPrice,
-        TrackingMode trackingMode, Warranty warranty, ProductConfigDto config)
+        TrackingMode trackingMode, Warranty warranty, ProductConfigDto config, TrackingMode? currentTrackingMode = null)
     {
+        var trackingUnchanged = trackingMode == currentTrackingMode;
         if (!config.SellingPricesEnabled &&
             (sellingMinPrice is not null || sellingMaxPrice is not null || sellingFlatPrice is not null))
             throw new DomainException(
@@ -506,13 +543,13 @@ public sealed class ItemService : IItemService
                 "Selling prices are disabled in the product configuration; sellingMinPrice, sellingMaxPrice and sellingFlatPrice must be null.",
                 422);
 
-        if (!config.SerialNumbersEnabled && trackingMode == TrackingMode.Serial)
+        if (!config.SerialNumbersEnabled && trackingMode == TrackingMode.Serial && !trackingUnchanged)
             throw new DomainException(
                 ErrorCodes.ConfigDisabled,
                 "Serial numbers are disabled in the product configuration; trackingMode cannot be Serial.",
                 422);
 
-        if (!config.BatchListsEnabled && trackingMode == TrackingMode.Batch)
+        if (!config.BatchListsEnabled && trackingMode == TrackingMode.Batch && !trackingUnchanged)
             throw new DomainException(
                 ErrorCodes.ConfigDisabled,
                 "Batch lists are disabled in the product configuration; trackingMode cannot be Batch.",
@@ -620,7 +657,7 @@ public sealed class ItemService : IItemService
 
     private static ItemScanResultDto ToScanResult(Serial s) => new(
         s.Item!.ItemId, s.Item.Sku, s.Item.Name, s.Item.TrackingMode, s.Item.BaseUomId, "Serial",
-        null, null, null, s.SerialId, s.SerialNo, s.Status);
+        null, null, null, s.SerialId, s.SerialNo, s.Status.ToString());
 
     private static ItemDetailDto ToDetail(Item i) => new(
         i.ItemId, i.Sku, i.Name, i.Description, i.CategoryId, i.SubCategoryId, i.BrandId,
diff --git a/Backend/ERPCore/Services/NotificationService.cs b/Backend/ERPCore/Services/NotificationService.cs
index 70708c9..cafb41a 100644
--- a/Backend/ERPCore/Services/NotificationService.cs
+++ b/Backend/ERPCore/Services/NotificationService.cs
@@ -39,16 +39,43 @@ public sealed class NotificationService : INotificationService
         int? relatedEntityId = null,
         CancellationToken ct = default)
     {
-        var channels = await _config.ResolveEnabledChannelsAsync(moduleKey, ct);
-        if (!channels.Contains(NotificationChannel.InApp)) return;
-
         var activeUserIds = await _users.Query().AsNoTracking()
             .Where(u => u.Status == EntityStatus.Active)
             .Select(u => u.UserId)
             .ToListAsync(ct);
 
+        await DeliverAsync(activeUserIds, moduleKey, title, message, relatedEntityType, relatedEntityId, ct);
+    }
+
+    public async Task NotifyUsersAsync(
+        IEnumerable<int> userIds,
+        string moduleKey,
+        string title,
+        string message,
+        string? relatedEntityType = null,
+        int? relatedEntityId = null,
+        CancellationToken ct = default)
+    {
+        var wanted = userIds.Distinct().ToList();
+        if (wanted.Count == 0) return;
+
+        var activeUserIds = await _users.Query().AsNoTracking()
+            .Where(u => u.Status == EntityStatus.Active && wanted.Contains(u.UserId))
+            .Select(u => u.UserId)
+            .ToListAsync(ct);
+
+        await DeliverAsync(activeUserIds, moduleKey, title, message, relatedEntityType, relatedEntityId, ct);
+    }
+
+    private async Task DeliverAsync(
+        List<int> activeUserIds, string moduleKey, string title, string message,
+        string? relatedEntityType, int? relatedEntityId, CancellationToken ct)
+    {
         if (activeUserIds.Count == 0) return;
 
+        var channels = await _config.ResolveEnabledChannelsAsync(moduleKey, ct);
+        if (!channels.Contains(NotificationChannel.InApp)) return;
+
         var notification = new Notification
         {
             ModuleKey = moduleKey,
diff --git a/Backend/ERPCore/Services/PriceAdjustmentService.cs b/Backend/ERPCore/Services/PriceAdjustmentService.cs
new file mode 100644
index 0000000..1984221
--- /dev/null
+++ b/Backend/ERPCore/Services/PriceAdjustmentService.cs
@@ -0,0 +1,364 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Products;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+/// <summary>
+/// Selling-price change requests (docs/DUAL_APPROVAL_PLAN.md §6). A request snapshots each item's
+/// current prices and the prices wanted; nothing changes until it is fully approved (rules in
+/// <see cref="IApprovalService"/>). Approval then writes the new prices to the items and records an
+/// <see cref="ItemPriceHistory"/> row — unless an item was repriced since the request was made, in
+/// which case the approval is refused as stale. One pending request per item at a time.
+/// </summary>
+public sealed class PriceAdjustmentService : IPriceAdjustmentService
+{
+    public const string ApprovalDocType = "PADJ";
+    public const string ApprovalNavCode = "products.price-adjustments";
+
+    private readonly IRepository<PriceAdjustment> _adjustments;
+    private readonly IRepository<Item> _items;
+    private readonly IRepository<ItemPriceHistory> _history;
+    private readonly IRepository<User> _users;
+    private readonly IRepository<ApprovalConfig> _config;
+    private readonly IApprovalService _approvals;
+    private readonly INotificationService _notifications;
+    private readonly INumberSequenceService _numbers;
+    private readonly ICurrentUser _currentUser;
+    private readonly IUnitOfWork _uow;
+
+    public PriceAdjustmentService(
+        IRepository<PriceAdjustment> adjustments, IRepository<Item> items, IRepository<ItemPriceHistory> history,
+        IRepository<User> users, IRepository<ApprovalConfig> config, IApprovalService approvals,
+        INotificationService notifications, INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow)
+    {
+        _adjustments = adjustments;
+        _items = items;
+        _history = history;
+        _users = users;
+        _config = config;
+        _approvals = approvals;
+        _notifications = notifications;
+        _numbers = numbers;
+        _currentUser = currentUser;
+        _uow = uow;
+    }
+
+    public async Task<PagedResponse<PriceAdjustmentSummaryDto>> ListAsync(PageQuery query, PriceAdjustmentStatus? status, int? itemId, CancellationToken ct = default)
+    {
+        var q = _adjustments.Query().AsNoTracking();
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(p => EF.Functions.Like(p.DocNo, $"%{term}%") || EF.Functions.Like(p.Reason, $"%{term}%"));
+        }
+        if (status is not null) q = q.Where(p => p.Status == status);
+        if (itemId is not null) q = q.Where(p => p.Lines.Any(l => l.ItemId == itemId));
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderByDescending(p => p.PriceAdjustmentId)
+            .Skip(query.Skip).Take(query.PageSize)
+            .Select(p => new PriceAdjustmentSummaryDto(
+                p.PriceAdjustmentId, p.DocNo, p.Reason, p.Status, p.RequiredApprovals,
+                p.Status == PriceAdjustmentStatus.PendingApproval ? 1 : p.Status == PriceAdjustmentStatus.PendingSecondApproval ? 2 : null,
+                p.Lines.Count, p.CreatedBy, p.Creator!.DisplayName, p.CreatedAt, p.AppliedAt))
+            .ToListAsync(ct);
+        return PagedResponse<PriceAdjustmentSummaryDto>.Create(rows, query.Page, query.PageSize, total);
+    }
+
+    public async Task<PriceAdjustmentDto?> GetAsync(int priceAdjustmentId, CancellationToken ct = default)
+    {
+        var adjustment = await Load(tracking: false).FirstOrDefaultAsync(p => p.PriceAdjustmentId == priceAdjustmentId, ct);
+        return adjustment is null ? null : await ToDtoAsync(adjustment, ct);
+    }
+
+    public async Task<PriceAdjustmentDto> CreateAsync(CreatePriceAdjustmentRequest request, CancellationToken ct = default)
+    {
+        var reason = request.Reason?.Trim();
+        if (string.IsNullOrEmpty(reason))
+            throw new DomainException(ErrorCodes.Validation, "Give a reason for the price change.", 400);
+        if (request.Lines.Count == 0)
+            throw new DomainException(ErrorCodes.Validation, "Add at least one item.", 400);
+        if (request.Lines.Select(l => l.ItemId).Distinct().Count() != request.Lines.Count)
+            throw new DomainException(ErrorCodes.Validation, "Each item can appear only once in a request.", 400);
+
+        var ids = request.Lines.Select(l => l.ItemId).ToList();
+        var items = await _items.Query().Where(i => ids.Contains(i.ItemId)).ToDictionaryAsync(i => i.ItemId, ct);
+        var pendingItemIds = await _adjustments.Query().AsNoTracking()
+            .Where(p => p.Status == PriceAdjustmentStatus.PendingApproval || p.Status == PriceAdjustmentStatus.PendingSecondApproval)
+            .SelectMany(p => p.Lines.Select(l => new { l.ItemId, p.DocNo }))
+            .Where(x => ids.Contains(x.ItemId))
+            .ToListAsync(ct);
+
+        var lines = new List<PriceAdjustmentLine>();
+        var largestChange = 0m;
+        foreach (var input in request.Lines)
+        {
+            if (!items.TryGetValue(input.ItemId, out var item))
+                throw new DomainException(ErrorCodes.Validation, $"Item {input.ItemId} does not exist.", 422);
+            var clash = pendingItemIds.FirstOrDefault(x => x.ItemId == input.ItemId);
+            if (clash is not null)
+                throw new DomainException(ErrorCodes.PriceAdjustmentItemPending,
+                    $"{item.Sku} already has a pending price change ({clash.DocNo}) — approve, reject or withdraw that first.", 409);
+            ValidatePrices(item.Sku, input.NewMinPrice, input.NewMaxPrice, input.NewFlatPrice);
+            if (input.NewMinPrice == item.SellingMinPrice && input.NewMaxPrice == item.SellingMaxPrice && input.NewFlatPrice == item.SellingFlatPrice)
+                throw new DomainException(ErrorCodes.Validation, $"{item.Sku}: the new prices are the same as the current ones.", 400);
+
+            largestChange = Math.Max(largestChange, Math.Max(
+                ChangePercent(item.SellingMinPrice, input.NewMinPrice),
+                Math.Max(ChangePercent(item.SellingMaxPrice, input.NewMaxPrice), ChangePercent(item.SellingFlatPrice, input.NewFlatPrice))));
+
+            lines.Add(new PriceAdjustmentLine
+            {
+                ItemId = item.ItemId,
+                OldMinPrice = item.SellingMinPrice, OldMaxPrice = item.SellingMaxPrice, OldFlatPrice = item.SellingFlatPrice,
+                NewMinPrice = input.NewMinPrice, NewMaxPrice = input.NewMaxPrice, NewFlatPrice = input.NewFlatPrice
+            });
+        }
+
+        var required = await _approvals.RequiredForPriceAdjustmentAsync(largestChange, ct);
+        var now = DateTime.UtcNow;
+        var adjustment = await _uow.ExecuteInTransactionAsync(async token =>
+        {
+            var entity = new PriceAdjustment
+            {
+                DocNo = await _numbers.NextAsync(DocumentTypes.PriceAdjustment, token),
+                Reason = reason,
+                Status = required == 0 ? PriceAdjustmentStatus.Approved : PriceAdjustmentStatus.PendingApproval,
+                RequiredApprovals = required,
+                CreatedBy = _currentUser.AuditUserId,
+                CreatedAt = now,
+                Lines = lines
+            };
+            await _adjustments.AddAsync(entity, token);
+            if (required == 0)
+                await ApplyInCurrentTransactionAsync(entity, items, now, token);
+            return entity;
+        }, ct);
+
+        if (required > 0)
+            await _approvals.NotifyPendingAsync(Target(adjustment), Summary(adjustment), ct);
+
+        return (await GetAsync(adjustment.PriceAdjustmentId, ct))!;
+    }
+
+    public async Task<PriceAdjustmentDto> ApproveAsync(int priceAdjustmentId, string? comment, CancellationToken ct = default)
+    {
+        var adjustment = await LoadPendingAsync(priceAdjustmentId, ct);
+        var target = Target(adjustment);
+        var outcome = await _approvals.DecideAsync(target, approve: true, comment, ct);
+        var now = DateTime.UtcNow;
+
+        if (target.CurrentLevel == 1)
+        {
+            adjustment.ApprovedLevel1By = _currentUser.AuditUserId;
+            adjustment.ApprovedLevel1At = now;
+        }
+        else
+        {
+            adjustment.ApprovedLevel2By = _currentUser.AuditUserId;
+            adjustment.ApprovedLevel2At = now;
+        }
+
+        try
+        {
+            await _uow.ExecuteInTransactionAsync(async token =>
+            {
+                if (outcome == ApprovalOutcome.AdvancedToLevel2)
+                {
+                    adjustment.Status = PriceAdjustmentStatus.PendingSecondApproval;
+                    return 0;
+                }
+                var ids = adjustment.Lines.Select(l => l.ItemId).ToList();
+                var items = await _items.Query().Where(i => ids.Contains(i.ItemId)).ToDictionaryAsync(i => i.ItemId, token);
+                adjustment.Status = PriceAdjustmentStatus.Approved;
+                await ApplyInCurrentTransactionAsync(adjustment, items, now, token);
+                return 0;
+            }, ct);
+        }
+        catch (DbUpdateConcurrencyException)
+        {
+            throw new DomainException(ErrorCodes.ApprovalNotPending, $"Price adjustment {adjustment.DocNo} was just decided by someone else — reload it.", 409);
+        }
+
+        if (outcome == ApprovalOutcome.AdvancedToLevel2)
+            await _approvals.NotifyPendingAsync(Target(adjustment), Summary(adjustment), ct);
+        else
+            await _notifications.NotifyUsersAsync([adjustment.CreatedBy], "approval.approved",
+                $"Approved: {adjustment.DocNo}", $"Price adjustment {adjustment.DocNo} was approved — the new prices are now in effect.",
+                ApprovalDocType, adjustment.PriceAdjustmentId, ct);
+
+        return (await GetAsync(adjustment.PriceAdjustmentId, ct))!;
+    }
+
+    public async Task<PriceAdjustmentDto> RejectAsync(int priceAdjustmentId, string reason, CancellationToken ct = default)
+    {
+        var adjustment = await LoadPendingAsync(priceAdjustmentId, ct);
+        await _approvals.DecideAsync(Target(adjustment), approve: false, reason, ct);
+
+        adjustment.Status = PriceAdjustmentStatus.Rejected;
+        adjustment.RejectedBy = _currentUser.AuditUserId;
+        adjustment.RejectedAt = DateTime.UtcNow;
+        adjustment.RejectReason = reason.Trim();
+        await SaveDecisionAsync(adjustment, ct);
+
+        await _notifications.NotifyUsersAsync([adjustment.CreatedBy], "approval.rejected",
+            $"Rejected: {adjustment.DocNo}", $"Price adjustment {adjustment.DocNo} was rejected: {adjustment.RejectReason}",
+            ApprovalDocType, adjustment.PriceAdjustmentId, ct);
+        return (await GetAsync(adjustment.PriceAdjustmentId, ct))!;
+    }
+
+    public async Task<PriceAdjustmentDto> CancelAsync(int priceAdjustmentId, CancellationToken ct = default)
+    {
+        var adjustment = await LoadPendingAsync(priceAdjustmentId, ct);
+        if (adjustment.CreatedBy != _currentUser.AuditUserId)
+            throw new DomainException(ErrorCodes.ApprovalForbidden, "Only the person who made the request can withdraw it.", 403);
+
+        adjustment.Status = PriceAdjustmentStatus.Cancelled;
+        adjustment.CancelledAt = DateTime.UtcNow;
+        await SaveDecisionAsync(adjustment, ct);
+        return (await GetAsync(adjustment.PriceAdjustmentId, ct))!;
+    }
+
+    public async Task<IReadOnlyList<ItemPriceHistoryDto>> ItemHistoryAsync(int itemId, CancellationToken ct = default)
+    {
+        var rows = await _history.Query().AsNoTracking()
+            .Where(h => h.ItemId == itemId)
+            .OrderByDescending(h => h.AppliedAt).ThenByDescending(h => h.ItemPriceHistoryId)
+            .ToListAsync(ct);
+
+        var userIds = rows.SelectMany(r => new int?[] { r.RequestedBy, r.ApprovedLevel1By, r.ApprovedLevel2By }).OfType<int>().Distinct().ToList();
+        var names = await _users.Query().AsNoTracking().Where(u => userIds.Contains(u.UserId)).ToDictionaryAsync(u => u.UserId, u => u.DisplayName, ct);
+        var docIds = rows.Select(r => r.PriceAdjustmentId).OfType<int>().Distinct().ToList();
+        var docNos = await _adjustments.Query().AsNoTracking().Where(p => docIds.Contains(p.PriceAdjustmentId)).ToDictionaryAsync(p => p.PriceAdjustmentId, p => p.DocNo, ct);
+
+        string? Name(int? id) => id is int v ? names.GetValueOrDefault(v) : null;
+        return rows.Select(h => new ItemPriceHistoryDto(
+            h.ItemPriceHistoryId, h.ItemId, h.PriceAdjustmentId, h.PriceAdjustmentId is int d ? docNos.GetValueOrDefault(d) : null,
+            h.OldMinPrice, h.OldMaxPrice, h.OldFlatPrice, h.NewMinPrice, h.NewMaxPrice, h.NewFlatPrice,
+            h.RequestedBy, Name(h.RequestedBy), h.ApprovedLevel1By, Name(h.ApprovedLevel1By), h.ApprovedLevel2By, Name(h.ApprovedLevel2By),
+            h.AppliedAt)).ToList();
+    }
+
+    public async Task<bool> PricesNeedApprovalAsync(CancellationToken ct = default)
+        => (await _config.Query().AsNoTracking().Where(c => c.ApprovalConfigId == ApprovalConfig.SingletonId)
+               .Select(c => (int?)c.PriceAdjustmentLevels).FirstOrDefaultAsync(ct) ?? 2) > 0;
+
+    // --- Helpers ---------------------------------------------------------------------------------
+
+    /// <summary>Writes each line's new prices to its item and records the history. Refuses the whole
+    /// request if any item's prices no longer match what the request was made against.</summary>
+    private async Task ApplyInCurrentTransactionAsync(PriceAdjustment adjustment, IReadOnlyDictionary<int, Item> items, DateTime now, CancellationToken ct)
+    {
+        foreach (var line in adjustment.Lines)
+        {
+            var item = items[line.ItemId];
+            if (item.SellingMinPrice != line.OldMinPrice || item.SellingMaxPrice != line.OldMaxPrice || item.SellingFlatPrice != line.OldFlatPrice)
+                throw new DomainException(ErrorCodes.PriceAdjustmentStale,
+                    $"{item.Sku}'s prices changed after {adjustment.DocNo} was requested. Reject this request and raise a new one against the current prices.", 409);
+
+            item.SellingMinPrice = line.NewMinPrice;
+            item.SellingMaxPrice = line.NewMaxPrice;
+            item.SellingFlatPrice = line.NewFlatPrice;
+            item.UpdatedAt = now;
+
+            await _history.AddAsync(new ItemPriceHistory
+            {
+                ItemId = item.ItemId,
+                PriceAdjustment = adjustment,   // FK set by EF, also when the request is new
+                OldMinPrice = line.OldMinPrice, OldMaxPrice = line.OldMaxPrice, OldFlatPrice = line.OldFlatPrice,
+                NewMinPrice = line.NewMinPrice, NewMaxPrice = line.NewMaxPrice, NewFlatPrice = line.NewFlatPrice,
+                RequestedBy = adjustment.CreatedBy,
+                ApprovedLevel1By = adjustment.ApprovedLevel1By,
+                ApprovedLevel2By = adjustment.ApprovedLevel2By,
+                AppliedAt = now
+            }, ct);
+        }
+        adjustment.AppliedAt = now;
+    }
+
+    private static void ValidatePrices(string sku, decimal? min, decimal? max, decimal? flat)
+    {
+        if (min < 0 || max < 0 || flat < 0)
+            throw new DomainException(ErrorCodes.Validation, $"{sku}: prices cannot be negative.", 400);
+        if (min is not null && max is not null && min > max)
+            throw new DomainException(ErrorCodes.Validation, $"{sku}: the minimum price is above the maximum.", 400);
+        if (flat is not null && ((min is not null && flat < min) || (max is not null && flat > max)))
+            throw new DomainException(ErrorCodes.Validation, $"{sku}: the flat price must be between the minimum and maximum.", 400);
+    }
+
+    /// <summary>Size of a change in percent; setting or clearing a price counts as 100%.</summary>
+    public static decimal ChangePercent(decimal? oldPrice, decimal? newPrice)
+    {
+        if (oldPrice == newPrice) return 0m;
+        if (oldPrice is null || newPrice is null || oldPrice == 0) return 100m;
+        return Math.Abs(newPrice.Value - oldPrice.Value) / oldPrice.Value * 100m;
+    }
+
+    private IQueryable<PriceAdjustment> Load(bool tracking)
+    {
+        var q = _adjustments.Query().Include(p => p.Lines).ThenInclude(l => l.Item).Include(p => p.Creator);
+        return tracking ? q : q.AsNoTracking();
+    }
+
+    private async Task<PriceAdjustment> LoadPendingAsync(int priceAdjustmentId, CancellationToken ct)
+    {
+        var adjustment = await _adjustments.Query().Include(p => p.Lines)
+            .FirstOrDefaultAsync(p => p.PriceAdjustmentId == priceAdjustmentId, ct)
+            ?? throw new NotFoundException($"Price adjustment {priceAdjustmentId} was not found.");
+        if (adjustment.Status is not (PriceAdjustmentStatus.PendingApproval or PriceAdjustmentStatus.PendingSecondApproval))
+            throw new DomainException(ErrorCodes.ApprovalNotPending, $"Price adjustment {adjustment.DocNo} is {adjustment.Status} and not waiting for approval.", 409);
+        return adjustment;
+    }
+
+    private async Task SaveDecisionAsync(PriceAdjustment adjustment, CancellationToken ct)
+    {
+        try
+        {
+            await _uow.SaveChangesAsync(ct);
+        }
+        catch (DbUpdateConcurrencyException)
+        {
+            throw new DomainException(ErrorCodes.ApprovalNotPending, $"Price adjustment {adjustment.DocNo} was just decided by someone else — reload it.", 409);
+        }
+    }
+
+    private static int? PendingLevel(PriceAdjustment p) => p.Status switch
+    {
+        PriceAdjustmentStatus.PendingApproval => 1,
+        PriceAdjustmentStatus.PendingSecondApproval => 2,
+        _ => null
+    };
+
+    private static ApprovalTarget Target(PriceAdjustment p) => new(
+        ApprovalDocType, p.PriceAdjustmentId, p.DocNo, ApprovalNavCode, p.CreatedBy, p.RequiredApprovals, PendingLevel(p) ?? 1, p.ApprovedLevel1By);
+
+    private static string Summary(PriceAdjustment p)
+        => $"Price adjustment {p.DocNo} ({p.Lines.Count} item{(p.Lines.Count == 1 ? "" : "s")}: {p.Reason})";
+
+    private async Task<PriceAdjustmentDto> ToDtoAsync(PriceAdjustment p, CancellationToken ct)
+    {
+        var pending = PendingLevel(p);
+        var whyNot = pending is null ? "Not waiting for approval." : await _approvals.WhyCannotDecideAsync(Target(p), ct);
+        return new PriceAdjustmentDto(
+            p.PriceAdjustmentId, p.DocNo, p.Reason, p.Status, p.RequiredApprovals, pending,
+            p.CreatedBy, p.Creator?.DisplayName, p.CreatedAt,
+            p.ApprovedLevel1By, p.ApprovedLevel1At, p.ApprovedLevel2By, p.ApprovedLevel2At,
+            p.RejectedBy, p.RejectedAt, p.RejectReason, p.CancelledAt, p.AppliedAt,
+            p.Lines.OrderBy(l => l.PriceAdjustmentLineId).Select(l => new PriceAdjustmentLineDto(
+                l.PriceAdjustmentLineId, l.ItemId, l.Item?.Sku ?? $"#{l.ItemId}", l.Item?.Name ?? string.Empty,
+                l.OldMinPrice, l.OldMaxPrice, l.OldFlatPrice, l.NewMinPrice, l.NewMaxPrice, l.NewFlatPrice,
+                l.Item?.SellingMinPrice, l.Item?.SellingMaxPrice, l.Item?.SellingFlatPrice)).ToList(),
+            await _approvals.HistoryAsync(ApprovalDocType, p.PriceAdjustmentId, ct),
+            whyNot is null, whyNot,
+            pending is not null && p.CreatedBy == _currentUser.AuditUserId);
+    }
+}
diff --git a/Backend/ERPCore/Services/PurchaseInvoicePaymentService.cs b/Backend/ERPCore/Services/PurchaseInvoicePaymentService.cs
index 66aec8c..b104526 100644
--- a/Backend/ERPCore/Services/PurchaseInvoicePaymentService.cs
+++ b/Backend/ERPCore/Services/PurchaseInvoicePaymentService.cs
@@ -59,15 +59,16 @@ public sealed class PurchaseInvoicePaymentService : IPurchaseInvoicePaymentServi
 
         var actor = _currentUser.AuditUserId;
         var now = DateTime.UtcNow;
+        var (paymentDay, paymentDate) = ResolvePaymentDate(request.PaymentDate, now);
 
         var payment = await _uow.ExecuteInTransactionAsync(async token =>
         {
             var glCodes = await _glAccounts.GetCodesAsync(token);
-            var period = await _gl.GetPeriodByDateAsync(BusinessClock.ToBusinessDate(now), token);
+            var period = await _gl.GetPeriodByDateAsync(paymentDay, token);
             var posted = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
             {
                 PeriodId = period.PeriodId,
-                EntryDate = BusinessClock.ToBusinessDate(now),
+                EntryDate = paymentDay,
                 SourceModule = "PURCHASE_INVOICE_PAYMENT",
                 Reference = invoice.DocNo,
                 Narration = $"Payment against invoice {invoice.DocNo}",
@@ -82,7 +83,7 @@ public sealed class PurchaseInvoicePaymentService : IPurchaseInvoicePaymentServi
             {
                 PurchaseInvoiceId = invoice.PurchaseInvoiceId,
                 Amount = request.Amount,
-                PaymentDate = now,
+                PaymentDate = paymentDate,
                 GlBankAccountId = account.AccountId,
                 BankAccountName = account.AccountName,
                 Reference = request.Reference,
@@ -101,6 +102,22 @@ public sealed class PurchaseInvoicePaymentService : IPurchaseInvoicePaymentServi
         return Map(payment);
     }
 
+    /// <summary>
+    /// The payment's calendar day (also the GL entry date) and the timestamp stored on it — same
+    /// rule as <see cref="SalesInvoicePaymentService"/>. Omitted ⇒ today — the <em>business</em> day
+    /// (<see cref="BusinessClock"/>), not the UTC one. One day of slack on
+    /// "future": the client sends its local date, which runs ahead of UTC for users east of it.
+    /// Today keeps the actual time of entry; a back-dated payment is stamped at that day's start.
+    /// </summary>
+    private static (DateOnly Day, DateTime Stamp) ResolvePaymentDate(DateOnly? requested, DateTime now)
+    {
+        var today = BusinessClock.ToBusinessDate(now);
+        var day = requested ?? today;
+        if (day > today.AddDays(1))
+            throw new DomainException(ErrorCodes.Validation, "Payment date cannot be in the future.", 400);
+        return (day, day >= today ? now : day.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc));
+    }
+
     public async Task<IReadOnlyList<PurchaseInvoicePaymentDto>> ListAsync(int purchaseInvoiceId, CancellationToken ct = default)
     {
         if (!await _invoices.Query().AnyAsync(i => i.PurchaseInvoiceId == purchaseInvoiceId, ct))
diff --git a/Backend/ERPCore/Services/PurchaseReturnService.cs b/Backend/ERPCore/Services/PurchaseReturnService.cs
index 54581e5..1dff8b2 100644
--- a/Backend/ERPCore/Services/PurchaseReturnService.cs
+++ b/Backend/ERPCore/Services/PurchaseReturnService.cs
@@ -38,6 +38,8 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
     private readonly IRepository<StockLedger> _ledger;
     private readonly IStockMutator _mutator;
     private readonly IFifoCostingService _fifo;
+    private readonly IRepository<Serial> _serials;
+    private readonly ISerialTrackingService _serialTracking;
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
     private readonly INotificationService _notifications;
@@ -49,9 +51,12 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
         IRepository<PurchaseReturn> returns, IRepository<Vendor> vendors, IRepository<Warehouse> warehouses,
         IRepository<Item> items, IRepository<ReasonCode> reasonCodes, IRepository<GrnLine> grnLines,
         IRepository<StockLayer> layers, IRepository<StockLedger> ledger, IStockMutator mutator, IFifoCostingService fifo,
+        IRepository<Serial> serials, ISerialTrackingService serialTracking,
         INumberSequenceService numbers, ICurrentUser currentUser, INotificationService notifications,
         IUnitOfWork uow, IGeneralLedgerService gl, IGlAccountConfigService glAccounts)
     {
+        _serials = serials;
+        _serialTracking = serialTracking;
         _returns = returns;
         _vendors = vendors;
         _warehouses = warehouses;
@@ -130,11 +135,24 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
         // layer(s) below, not the generic mutator — track which by GrnLineId so the two
         // paths don't double-handle the same line.
         var rejectedGrnLineIds = new HashSet<int>();
+        var documentSerials = new HashSet<int>();
+        var serialsByLine = new Dictionary<CreatePurchaseReturnLineInput, IReadOnlyList<Serial>>();
 
         foreach (var line in request.Lines)
         {
-            if (!await _items.Query().AnyAsync(i => i.ItemId == line.ItemId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+            var item = await _items.Query().AsNoTracking().FirstOrDefaultAsync(i => i.ItemId == line.ItemId, ct)
+                ?? throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+
+            // Rejected-line serials are checked against that line's own layers below; anything
+            // else must name serials actually on hand (D6: or leave only pre-tracking stock).
+            var isRejectedLine = line.GrnLineId is not null && await _grnLines.Query().AnyAsync(g => g.GrnLineId == line.GrnLineId && g.HoldStatus == HoldStatus.Rejected, ct);
+            if (!isRejectedLine || line.SerialIds is { Count: > 0 })
+                serialsByLine[line] = await _serialTracking.ResolveOutboundAsync(
+                    item, request.WarehouseId, line.Qty, line.SerialIds, documentSerials,
+                    new[] { SerialStatus.InStock, SerialStatus.Damaged }, ct);
+            if (isRejectedLine && serialsByLine.TryGetValue(line, out var named) && named.Any(s => s.GrnLineId != line.GrnLineId))
+                throw new DomainException(ErrorCodes.SerialNotAvailable, $"Some serials were not received on GRN line {line.GrnLineId}.", 422);
+
             if (line.GrnLineId is not null)
             {
                 var grnLine = await _grnLines.Query().AsNoTracking().FirstOrDefaultAsync(g => g.GrnLineId == line.GrnLineId, ct)
@@ -158,7 +176,8 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
         var actor = _currentUser.AuditUserId;
         var deltas = request.Lines
             .Where(l => l.GrnLineId is null || !rejectedGrnLineIds.Contains(l.GrnLineId.Value))
-            .Select(l => new StockDelta(l.ItemId, null, null, -l.Qty)).ToList();
+            .Select(l => new StockDelta(l.ItemId, null, null, -l.Qty,
+                serialsByLine.TryGetValue(l, out var s) ? s.Select(x => x.SerialId).ToList() : null)).ToList();
         var rejectedLines = request.Lines.Where(l => l.GrnLineId is not null && rejectedGrnLineIds.Contains(l.GrnLineId.Value)).ToList();
 
         var (entity, ledgerEntries) = await _uow.ExecuteInTransactionAsync(async token =>
@@ -196,10 +215,31 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
                     .OrderBy(l => l.ReceiptDate).ThenBy(l => l.LayerId)
                     .ToListAsync(token);
 
+                // A serial line's layers are one per unit: named serials take exactly theirs;
+                // with none named, the whole remaining line may go back (every serial on it).
+                var named = serialsByLine.TryGetValue(line, out var lineSerials) ? lineSerials : Array.Empty<Serial>();
+                if (named.Count > 0)
+                {
+                    var ids = named.Select(s => s.SerialId).ToHashSet();
+                    layers = layers.Where(l => l.SerialId != null && ids.Contains(l.SerialId.Value)).ToList();
+                    if (layers.Count != named.Count)
+                        throw new DomainException(ErrorCodes.SerialNotAvailable, $"Some serials are no longer on GRN line {line.GrnLineId}'s rejected stock.", 409);
+                }
+                else if (layers.Any(l => l.SerialId != null) && await _serialTracking.IsEnabledAsync(token))
+                {
+                    if (line.Qty != layers.Sum(l => l.QtyRemaining))
+                        throw new DomainException(ErrorCodes.TrackingRequired,
+                            $"GRN line {line.GrnLineId} is serial-tracked; select which {line.Qty} serial(s) go back.", 422);
+                    named = await _serials.Query()
+                        .Where(s => layers.Select(l => l.SerialId).Contains(s.SerialId)).ToListAsync(token);
+                    serialsByLine[line] = named;
+                }
+
                 if (!balances.TryGetValue(line.ItemId, out var bal))
                     bal = await _fifo.GetOnHandAsync(line.ItemId, request.WarehouseId, token);
 
                 var remaining = line.Qty;
+                var takenSerialIds = new List<int>();
                 foreach (var layer in layers)
                 {
                     if (remaining <= 0) break;
@@ -207,6 +247,7 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
                     layer.QtyRemaining -= take;
                     remaining -= take;
                     bal -= take;
+                    if (layer.SerialId is int takenSerial && layer.QtyRemaining == 0) takenSerialIds.Add(takenSerial);
 
                     var entry = await _fifo.PostLedgerAsync(
                         layer.ItemId, layer.WarehouseId, null, layer.BatchId, null, actor,
@@ -214,8 +255,17 @@ public sealed class PurchaseReturnService : IPurchaseReturnService
                     refs.Add(entry);
                 }
                 balances[line.ItemId] = bal;
+
+                // Serial numbers switched off: serial units went back oldest-first without being
+                // named — still record them as returned so the register doesn't show them in stock.
+                if (named.Count == 0 && takenSerialIds.Count > 0)
+                    serialsByLine[line] = await _serials.Query().Where(s => takenSerialIds.Contains(s.SerialId)).ToListAsync(token);
             }
 
+            foreach (var serials in serialsByLine.Values)
+                await _serialTracking.MoveAsync(serials, SerialStatus.ReturnedToVendor, null, null,
+                    DocumentTypes.PurchaseReturn, ret.ReturnId, now, token);
+
             var totalValue = refs.Sum(r => r.Value);
             if (totalValue > 0)
             {
diff --git a/Backend/ERPCore/Services/RequisitionService.cs b/Backend/ERPCore/Services/RequisitionService.cs
index 36b096c..06dfc5a 100644
--- a/Backend/ERPCore/Services/RequisitionService.cs
+++ b/Backend/ERPCore/Services/RequisitionService.cs
@@ -66,7 +66,11 @@ public sealed class RequisitionService : IRequisitionService
     {
         await EnsureItemsExistAsync(request.Lines.Select(l => l.ItemId), ct);
         var actor = _currentUser.AuditUserId;
-        var branchId = await _branchConfig.ResolveBranchIdAsync(request.BranchId, ct);
+        // Branch is optional on a requisition: an unset one falls back to the default branch
+        // rather than being rejected (this also covers reorder-alert requisitions, which carry none).
+        var branchId = request.BranchId > 0
+            ? await _branchConfig.ResolveBranchIdAsync(request.BranchId, ct)
+            : await _branchConfig.ResolveDefaultBranchIdAsync(ct);
 
         var req = await _uow.ExecuteInTransactionAsync(async token =>
         {
diff --git a/Backend/ERPCore/Services/SalesDocumentWorkflowService.cs b/Backend/ERPCore/Services/SalesDocumentWorkflowService.cs
index e3a8780..20b54ce 100644
--- a/Backend/ERPCore/Services/SalesDocumentWorkflowService.cs
+++ b/Backend/ERPCore/Services/SalesDocumentWorkflowService.cs
@@ -20,7 +20,7 @@ public sealed class SalesDocumentWorkflowService : ISalesDocumentWorkflowService
 
     public async Task<SalesInvoice> LoadEditableInvoiceAsync(int salesInvoiceId, uint expectedRowVersion, CancellationToken ct = default)
     {
-        var invoice = await _invoices.Query().Include(x => x.Lines)
+        var invoice = await _invoices.Query().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct)
             ?? throw new NotFoundException($"Sales invoice {salesInvoiceId} was not found.");
         if (invoice.RowVersion != expectedRowVersion)
@@ -32,7 +32,7 @@ public sealed class SalesDocumentWorkflowService : ISalesDocumentWorkflowService
 
     public async Task<SalesSlip> LoadEditableSlipAsync(int salesSlipId, uint expectedRowVersion, CancellationToken ct = default)
     {
-        var slip = await _slips.Query().Include(x => x.Lines)
+        var slip = await _slips.Query().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct)
             ?? throw new NotFoundException($"Sales slip {salesSlipId} was not found.");
         if (slip.RowVersion != expectedRowVersion)
diff --git a/Backend/ERPCore/Services/SalesDomainService.cs b/Backend/ERPCore/Services/SalesDomainService.cs
index 8e974b1..a07c8d6 100644
--- a/Backend/ERPCore/Services/SalesDomainService.cs
+++ b/Backend/ERPCore/Services/SalesDomainService.cs
@@ -16,6 +16,10 @@ public sealed class SalesDomainService : ISalesDomainService
     private readonly IRepository<TaxRate> _taxRates;
     private readonly ISalesPricingService _pricing;
     private readonly IRepository<SalesConfig> _salesConfig;
+    private readonly IRepository<Batch> _batches;
+    private readonly IRepository<Serial> _serials;
+    private readonly IRepository<StockLayer> _layers;
+    private readonly ISerialTrackingService _serialTracking;
 
     public SalesDomainService(
         IRepository<Customer> customers,
@@ -24,8 +28,16 @@ public sealed class SalesDomainService : ISalesDomainService
         IRepository<Item> items,
         IRepository<TaxRate> taxRates,
         ISalesPricingService pricing,
-        IRepository<SalesConfig> salesConfig)
+        IRepository<SalesConfig> salesConfig,
+        IRepository<Batch> batches,
+        IRepository<Serial> serials,
+        IRepository<StockLayer> layers,
+        ISerialTrackingService serialTracking)
     {
+        _serialTracking = serialTracking;
+        _batches = batches;
+        _serials = serials;
+        _layers = layers;
         _customers = customers;
         _warehouses = warehouses;
         _users = users;
@@ -154,6 +166,66 @@ public sealed class SalesDomainService : ISalesDomainService
             .Select(x => x.StockNature == StockNature.Stocked)
             .FirstAsync(ct);
 
+    public async Task<IReadOnlyList<Serial>> ValidateLineTrackingAsync(
+        int itemId, int warehouseId, decimal totalQty, int? batchId, IReadOnlyCollection<int>? serialIds,
+        ISet<int> documentSerials, CancellationToken ct = default)
+    {
+        var item = await _items.Query().AsNoTracking().FirstAsync(i => i.ItemId == itemId, ct);
+        var ids = serialIds?.ToList() ?? new List<int>();
+
+        if (batchId is not null)
+        {
+            var batch = await _batches.Query().AsNoTracking().FirstOrDefaultAsync(b => b.BatchId == batchId && b.ItemId == itemId, ct)
+                ?? throw new DomainException(ErrorCodes.Validation, $"Batch {batchId} does not belong to item {item.Sku}.", 422);
+            if (batch.ExpiryDate is DateOnly expiry && expiry < DateOnly.FromDateTime(DateTime.UtcNow))
+                throw new DomainException(ErrorCodes.ExpiredBatchBlocked, $"Batch {batch.BatchNo} expired on {expiry:yyyy-MM-dd} and cannot be sold.", 422);
+        }
+
+        // Serial numbers switched off in Product Configuration: a serial-mode item sells like
+        // untracked stock (no serials asked, none accepted).
+        if (!await _serialTracking.IsSerialTrackedAsync(item, ct))
+        {
+            _serialTracking.RejectSerialsWhileDisabled(item, ids.Count);
+            if (ids.Count > 0)
+                throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is not serial-tracked; serials are not accepted.", 422);
+            return Array.Empty<Serial>();
+        }
+
+        if (ids.Count == 0)
+        {
+            // D6: stock received before serial capture has no serials — it can still be sold
+            // without naming any, but only while enough of it is left at this warehouse.
+            if (item.StockNature != StockNature.Stocked) return Array.Empty<Serial>();
+            var untracked = await _layers.Query().AsNoTracking()
+                .Where(l => l.ItemId == itemId && l.WarehouseId == warehouseId && l.SerialId == null && l.QtyRemaining > 0)
+                .SumAsync(l => (decimal?)l.QtyRemaining, ct) ?? 0m;
+            if (untracked < totalQty)
+                throw new DomainException(ErrorCodes.TrackingRequired,
+                    $"Item {item.Sku} is serial-tracked; select {totalQty} serial number(s).", 422);
+            return Array.Empty<Serial>();
+        }
+
+        if (ids.Count != totalQty)
+            throw new DomainException(ErrorCodes.TrackingRequired,
+                $"Item {item.Sku} is serial-tracked; select exactly {totalQty} serial number(s), got {ids.Count}.", 422);
+        foreach (var id in ids)
+            if (!documentSerials.Add(id))
+                throw new DomainException(ErrorCodes.SerialDuplicate, $"Serial {id} is selected more than once on this document.", 422);
+
+        // Tracked on purpose: the caller hangs these off the new line's serial rows as navigations.
+        var serials = await _serials.Query().Where(s => ids.Contains(s.SerialId)).ToListAsync(ct);
+        foreach (var id in ids)
+        {
+            var serial = serials.FirstOrDefault(s => s.SerialId == id);
+            if (serial is null || serial.ItemId != itemId)
+                throw new DomainException(ErrorCodes.Validation, $"Serial {id} does not belong to item {item.Sku}.", 422);
+            if (serial.Status != SerialStatus.InStock || serial.WarehouseId != warehouseId)
+                throw new DomainException(ErrorCodes.SerialNotAvailable,
+                    $"Serial {serial.SerialNo} is {serial.Status}{(serial.Status == SerialStatus.InStock ? " at another warehouse" : string.Empty)} and cannot be sold from warehouse {warehouseId}.", 422);
+        }
+        return serials;
+    }
+
     private static decimal CalculateDiscount(decimal gross, SalesDiscountMode mode, decimal discountPct, decimal discountValue, decimal legacyDiscountAmount)
     {
         var computed = mode == SalesDiscountMode.Amount
diff --git a/Backend/ERPCore/Services/SalesInvoicePaymentService.cs b/Backend/ERPCore/Services/SalesInvoicePaymentService.cs
index 5018125..9b74518 100644
--- a/Backend/ERPCore/Services/SalesInvoicePaymentService.cs
+++ b/Backend/ERPCore/Services/SalesInvoicePaymentService.cs
@@ -91,6 +91,7 @@ public sealed class SalesInvoicePaymentService : ISalesInvoicePaymentService
                 PaymentDate = paymentDate,
                 GlBankAccountId = account.AccountId,
                 BankAccountName = account.AccountName,
+                PaymentMethod = ResolveMethod(request.PaymentMethod, account),
                 Reference = request.Reference,
                 GlJournalNo = posted.JournalNo,
                 CreatedBy = actor,
@@ -151,16 +152,17 @@ public sealed class SalesInvoicePaymentService : ISalesInvoicePaymentService
 
         // Oldest invoice first: walk the lines in order, filling each invoice's balance before the next.
         var ordered = invoices.OrderBy(i => i.InvoiceDate).ThenBy(i => i.SalesInvoiceId).ToList();
-        var allocations = new List<(SalesInvoice Invoice, GlBankAccount Account, decimal Amount)>();
+        var allocations = new List<(SalesInvoice Invoice, GlBankAccount Account, SalesPaymentMethod Method, decimal Amount)>();
         var invIdx = 0;
         var invRemaining = ordered[0].BalanceAmount;
         foreach (var (line, account) in lines)
         {
             var lineRemaining = line.Amount;
+            var method = ResolveMethod(line.PaymentMethod, account);
             while (lineRemaining > 0)
             {
                 var take = Math.Min(lineRemaining, invRemaining);
-                allocations.Add((ordered[invIdx], account, take));
+                allocations.Add((ordered[invIdx], account, method, take));
                 lineRemaining -= take;
                 invRemaining -= take;
                 if (invRemaining == 0 && invIdx < ordered.Count - 1)
@@ -196,7 +198,7 @@ public sealed class SalesInvoicePaymentService : ISalesInvoicePaymentService
             }, token);
 
             var entities = new List<SalesInvoicePayment>();
-            foreach (var (invoice, account, amount) in allocations)
+            foreach (var (invoice, account, method, amount) in allocations)
             {
                 var entity = new SalesInvoicePayment
                 {
@@ -205,6 +207,7 @@ public sealed class SalesInvoicePaymentService : ISalesInvoicePaymentService
                     PaymentDate = paymentDate,
                     GlBankAccountId = account.AccountId,
                     BankAccountName = account.AccountName,
+                    PaymentMethod = method,
                     Reference = request.Reference,
                     GlJournalNo = posted.JournalNo,
                     CreatedBy = actor,
@@ -238,6 +241,13 @@ public sealed class SalesInvoicePaymentService : ISalesInvoicePaymentService
         return (day, day >= today ? now : day.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc));
     }
 
+    /// <summary>The caller's method, or — when omitted (older clients) — the account's kind: money into a
+    /// Cash account is cash, money into a Bank account is taken to be a card payment.</summary>
+    private static SalesPaymentMethod ResolveMethod(SalesPaymentMethod? requested, GlBankAccount account)
+        => requested ?? (string.Equals(account.AccountType, "Cash", StringComparison.OrdinalIgnoreCase)
+            ? SalesPaymentMethod.Cash
+            : SalesPaymentMethod.Card);
+
     public async Task<IReadOnlyList<SalesInvoicePaymentDto>> ListAsync(int salesInvoiceId, CancellationToken ct = default)
     {
         if (!await _invoices.Query().AnyAsync(i => i.SalesInvoiceId == salesInvoiceId, ct))
@@ -248,11 +258,11 @@ public sealed class SalesInvoicePaymentService : ISalesInvoicePaymentService
             .OrderByDescending(p => p.SalesInvoicePaymentId)
             .Select(p => new SalesInvoicePaymentDto(
                 p.SalesInvoicePaymentId, p.SalesInvoiceId, p.Amount, p.PaymentDate,
-                p.GlBankAccountId, p.BankAccountName, p.Reference, p.GlJournalNo, p.CreatedAt))
+                p.GlBankAccountId, p.BankAccountName, p.Reference, p.GlJournalNo, p.CreatedAt, p.PaymentMethod))
             .ToListAsync(ct);
     }
 
     private static SalesInvoicePaymentDto Map(SalesInvoicePayment p) => new(
         p.SalesInvoicePaymentId, p.SalesInvoiceId, p.Amount, p.PaymentDate,
-        p.GlBankAccountId, p.BankAccountName, p.Reference, p.GlJournalNo, p.CreatedAt);
+        p.GlBankAccountId, p.BankAccountName, p.Reference, p.GlJournalNo, p.CreatedAt, p.PaymentMethod);
 }
diff --git a/Backend/ERPCore/Services/SalesInvoiceService.cs b/Backend/ERPCore/Services/SalesInvoiceService.cs
index 9b4b7bb..23c73b7 100644
--- a/Backend/ERPCore/Services/SalesInvoiceService.cs
+++ b/Backend/ERPCore/Services/SalesInvoiceService.cs
@@ -81,7 +81,7 @@ public sealed class SalesInvoiceService : ISalesInvoiceService
 
     public async Task<ETagged<SalesInvoiceDto>?> GetAsync(int salesInvoiceId, CancellationToken ct = default)
     {
-        var invoice = await _invoices.Query().AsNoTracking().Include(x => x.Lines)
+        var invoice = await _invoices.Query().AsNoTracking().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct);
         return invoice is null ? null : new ETagged<SalesInvoiceDto>(_mapping.MapInvoice(invoice), invoice.RowVersion);
     }
@@ -155,14 +155,14 @@ public sealed class SalesInvoiceService : ISalesInvoiceService
     public async Task<SalesInvoiceDto> PostAsync(int salesInvoiceId, CancellationToken ct = default)
         {
             await _posting.PostInvoiceAsync(salesInvoiceId, ct);
-            var invoice = await _invoices.Query().AsNoTracking().Include(x => x.Lines)
+            var invoice = await _invoices.Query().AsNoTracking().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
                 .FirstAsync(x => x.SalesInvoiceId == salesInvoiceId, ct);
             return _mapping.MapInvoice(invoice);
         }
 
     public async Task<SalesInvoiceDto> CancelAsync(int salesInvoiceId, CancellationToken ct = default)
     {
-        var invoice = await _invoices.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct)
+        var invoice = await _invoices.Query().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct)
             ?? throw new NotFoundException($"Sales invoice {salesInvoiceId} was not found.");
         if (invoice.Status != SalesInvoiceStatus.Draft)
             throw new ConflictException($"Sales invoice {salesInvoiceId} is {invoice.Status} and cannot be cancelled.");
@@ -188,10 +188,12 @@ public sealed class SalesInvoiceService : ISalesInvoiceService
             throw new DomainException(ErrorCodes.Validation, "Free items are turned off in Sales Configuration.", 422);
         if (requests.Any(r => r.DiscountPct > 0m || r.DiscountAmount > 0m || r.DiscountValue > 0m) && !await _sales.AreDiscountsAllowedAsync(ct))
             throw new DomainException(ErrorCodes.Validation, "Discounts are turned off in Sales Configuration.", 422);
+        var documentSerials = new HashSet<int>();
         foreach (var r in requests)
         {
             var item = await _items.Query().AsNoTracking().FirstAsync(x => x.ItemId == r.ItemId, ct);
             await _sales.ValidateSalesLineAsync(headerWarehouseId, r.ItemId, r.WarehouseId, r.Qty, r.FreeQty, r.ParentLineId, ct);
+            var serials = await _sales.ValidateLineTrackingAsync(r.ItemId, r.WarehouseId, r.Qty + r.FreeQty, r.BatchId, r.SerialIds, documentSerials, ct);
             var resolved = await _sales.ResolveLinePriceAsync(r.ItemId, r.WarehouseId, r.UnitPrice, r.AllowManualPriceOverride, ct);
             var unitPrice = resolved.UnitPrice;
             var priceSource = resolved.PriceSource;
@@ -217,7 +219,9 @@ public sealed class SalesInvoiceService : ISalesInvoiceService
                 TaxPct = taxPct,
                 TaxAmount = calc.TaxAmount,
                 IsFreeIssue = r.IsFreeIssue,
-                ParentLineId = r.ParentLineId
+                ParentLineId = r.ParentLineId,
+                BatchId = r.BatchId,
+                Serials = serials.Select(s => new SalesInvoiceLineSerial { SerialId = s.SerialId, Serial = s }).ToList()
             });
         }
         return lines;
diff --git a/Backend/ERPCore/Services/SalesMappingService.cs b/Backend/ERPCore/Services/SalesMappingService.cs
index bb1d866..50761de 100644
--- a/Backend/ERPCore/Services/SalesMappingService.cs
+++ b/Backend/ERPCore/Services/SalesMappingService.cs
@@ -26,7 +26,9 @@ public sealed class SalesMappingService : ISalesMappingService
             slip.TaxTotal,
             slip.GrandTotal,
             slip.PaidAmount,
-            slip.BalanceAmount);
+            slip.BalanceAmount,
+            slip.CashAmount,
+            slip.CardAmount);
 
     public SalesInvoiceDto MapInvoice(SalesInvoice invoice)
         => new(
@@ -38,7 +40,8 @@ public sealed class SalesMappingService : ISalesMappingService
             invoice.Lines.Select(l => new SalesInvoiceLineDto(
                 l.SalesInvoiceLineId, l.ItemId, l.Description, l.Qty, l.FreeQty, l.WarehouseId,
                 l.UnitPrice, l.BaseCost, l.PriceSource, l.DiscountPct, l.DiscountAmount, l.DiscountMode,
-                l.NetUnitPrice, l.LineTotal, l.TaxPct, l.TaxAmount, l.IsFreeIssue, l.ParentLineId)).ToList());
+                l.NetUnitPrice, l.LineTotal, l.TaxPct, l.TaxAmount, l.IsFreeIssue, l.ParentLineId,
+                l.BatchId, l.Serials.Select(s => new SalesLineSerialDto(s.SerialId, s.Serial?.SerialNo ?? string.Empty)).ToList())).ToList());
 
     public SalesSlipDto MapSlip(SalesSlip slip)
         => new(
@@ -49,5 +52,6 @@ public sealed class SalesMappingService : ISalesMappingService
                 l.SalesSlipLineId, l.ItemId, l.Description, l.Qty, l.FreeQty, l.WarehouseId,
                 l.UnitPrice, l.BaseCost, l.PriceSource, l.DiscountPct, l.DiscountAmount, l.DiscountMode,
                 l.NetUnitPrice, l.LineTotal, l.TaxPct, l.TaxAmount, l.IsFreeIssue, l.ParentLineId,
-                l.BatchId, l.SerialId)).ToList());
+                l.BatchId, l.SerialId,
+                l.Serials.Select(s => new SalesLineSerialDto(s.SerialId, s.Serial?.SerialNo ?? string.Empty)).ToList())).ToList());
 }
diff --git a/Backend/ERPCore/Services/SalesPostingService.cs b/Backend/ERPCore/Services/SalesPostingService.cs
index adfcd1f..4385931 100644
--- a/Backend/ERPCore/Services/SalesPostingService.cs
+++ b/Backend/ERPCore/Services/SalesPostingService.cs
@@ -21,6 +21,10 @@ public sealed class SalesPostingService : ISalesPostingService
     private readonly IRepository<BundleSale> _bundles;
     private readonly IRepository<Item> _items;
     private readonly IRepository<Serial> _serials;
+    private readonly IRepository<SalesLineAllocation> _allocations;
+    private readonly IRepository<WarrantyRegistration> _warranties;
+    private readonly IRepository<SerialMovement> _serialMovements;
+    private readonly ISerialTrackingService _serialTracking;
     private readonly IFifoCostingService _fifo;
     private readonly ISalesDomainService _sales;
     private readonly ICurrentUser _currentUser;
@@ -34,6 +38,10 @@ public sealed class SalesPostingService : ISalesPostingService
         IRepository<BundleSale> bundles,
         IRepository<Item> items,
         IRepository<Serial> serials,
+        IRepository<SalesLineAllocation> allocations,
+        IRepository<WarrantyRegistration> warranties,
+        IRepository<SerialMovement> serialMovements,
+        ISerialTrackingService serialTracking,
         IFifoCostingService fifo,
         ISalesDomainService sales,
         ICurrentUser currentUser,
@@ -46,6 +54,10 @@ public sealed class SalesPostingService : ISalesPostingService
         _bundles = bundles;
         _items = items;
         _serials = serials;
+        _allocations = allocations;
+        _warranties = warranties;
+        _serialMovements = serialMovements;
+        _serialTracking = serialTracking;
         _fifo = fifo;
         _sales = sales;
         _currentUser = currentUser;
@@ -150,15 +162,17 @@ public sealed class SalesPostingService : ISalesPostingService
 
     public Task PostInvoiceAsync(int salesInvoiceId, CancellationToken ct = default)
         => PostAsync(
-            load: () => _invoices.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct),
+            load: () => _invoices.Query().Include(x => x.Lines).ThenInclude(l => l.Serials).FirstOrDefaultAsync(x => x.SalesInvoiceId == salesInvoiceId, ct),
             notFoundMessage: $"Sales invoice {salesInvoiceId} was not found.",
             statusSelector: x => x.Status,
             ensureDraftMessage: x => $"Sales invoice {x.SalesInvoiceId} is {x.Status} and cannot be posted.",
-            getLines: x => x.Lines.Select(l => new PostingLine(l.ItemId, l.WarehouseId, l.Qty + l.FreeQty, l.Qty, l.FreeQty, null, null)),
+            getLines: x => x.Lines.Select(l => new PostingLine(l.SalesInvoiceLineId, l.ItemId, l.WarehouseId, l.Qty + l.FreeQty, l.Qty, l.FreeQty,
+                l.BatchId, l.Serials.Select(s => s.SerialId).ToList())),
             setPosted: x => x.Status = SalesInvoiceStatus.Posted,
             setUpdated: x => x.UpdatedAt = DateTime.UtcNow,
             sourceDocType: DocumentTypes.SalesInvoice,
             getDocId: x => x.SalesInvoiceId,
+            getCustomerId: x => x.CustomerId,
             ct: ct,
             afterConsumption: PostInvoiceRevenueAsync);
 
@@ -208,15 +222,19 @@ public sealed class SalesPostingService : ISalesPostingService
 
     public Task PostSlipAsync(int salesSlipId, CancellationToken ct = default)
         => PostAsync(
-            load: () => _slips.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct),
+            load: () => _slips.Query().Include(x => x.Lines).ThenInclude(l => l.Serials).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct),
             notFoundMessage: $"Sales slip {salesSlipId} was not found.",
             statusSelector: x => x.Status,
             ensureDraftMessage: x => $"Sales slip {x.SalesSlipId} is {x.Status} and cannot be posted.",
-            getLines: x => x.Lines.Select(l => new PostingLine(l.ItemId, l.WarehouseId, l.Qty + l.FreeQty, l.Qty, l.FreeQty, l.BatchId, l.SerialId)),
+            // An old draft may still carry only the legacy single SerialId.
+            getLines: x => x.Lines.Select(l => new PostingLine(l.SalesSlipLineId, l.ItemId, l.WarehouseId, l.Qty + l.FreeQty, l.Qty, l.FreeQty, l.BatchId,
+                l.Serials.Count > 0 ? l.Serials.Select(s => s.SerialId).ToList()
+                : l.SerialId is int single ? new List<int> { single } : new List<int>())),
             setPosted: x => x.Status = SalesSlipStatus.Posted,
             setUpdated: x => x.UpdatedAt = DateTime.UtcNow,
             sourceDocType: DocumentTypes.SalesSlip,
             getDocId: x => x.SalesSlipId,
+            getCustomerId: x => x.CustomerId,
             ct: ct);
 
     public Task PostBundleAsync(int bundleSaleId, CancellationToken ct = default)
@@ -225,11 +243,12 @@ public sealed class SalesPostingService : ISalesPostingService
             notFoundMessage: $"Bundle sale {bundleSaleId} was not found.",
             statusSelector: x => x.Status,
             ensureDraftMessage: x => $"Bundle sale {x.BundleSaleId} is {x.Status} and cannot be posted.",
-            getLines: x => x.Lines.Where(l => l.IncludeInBundle).Select(l => new PostingLine(l.ItemId, l.WarehouseId, l.Qty, l.Qty, 0m, null, null)),
+            getLines: x => x.Lines.Where(l => l.IncludeInBundle).Select(l => new PostingLine(l.BundleSaleLineId, l.ItemId, l.WarehouseId, l.Qty, l.Qty, 0m, null, new List<int>())),
             setPosted: x => x.Status = BundleSaleStatus.Posted,
             setUpdated: x => x.UpdatedAt = DateTime.UtcNow,
             sourceDocType: DocumentTypes.BundleSale,
             getDocId: x => x.BundleSaleId,
+            getCustomerId: x => x.CustomerId,
             ct: ct);
 
     private async Task PostAsync<T>(
@@ -242,6 +261,7 @@ public sealed class SalesPostingService : ISalesPostingService
         Action<T> setUpdated,
         string sourceDocType,
         Func<T, int> getDocId,
+        Func<T, int> getCustomerId,
         CancellationToken ct,
         /// <summary>Run inside the same transaction, after consumption and status flip, with the
         /// total COGS this call just consumed — the invoice-only revenue-recognition hook.
@@ -262,27 +282,65 @@ public sealed class SalesPostingService : ISalesPostingService
         await _uow.ExecuteInTransactionAsync(async token =>
         {
             var totalCogs = 0m;
+            var now = DateTime.UtcNow;
+            var docId = getDocId(doc);
             foreach (var line in getLines(doc))
             {
                 if (line.Qty <= 0) continue;
-                if (!await _sales.IsStockedItemAsync(line.ItemId, token))
+                var item = await _items.Query().AsNoTracking().FirstAsync(i => i.ItemId == line.ItemId, token);
+                if (item.StockNature != StockNature.Stocked)
                     continue;
 
+                var serials = await LoadSerialsForPostingAsync(item, line, token);
+
                 // Line quantities are already a count of the item's base UOM — sales documents
                 // carry no unit of their own — so this is the quantity FIFO consumes verbatim.
-                var consumed = await _fifo.ConsumeAsync(line.ItemId, line.WarehouseId, line.BatchId, line.Qty, token, allowShortfall);
-                var cost = consumed.Count == 0 ? 0m : consumed.Sum(x => x.Qty * x.UnitCost) / consumed.Sum(x => x.Qty);
-                totalCogs += cost * line.Qty;
-                await _fifo.PostLedgerAsync(line.ItemId, line.WarehouseId, null, line.BatchId, line.SerialId, _currentUser.AuditUserId,
-                    Direction.Out, line.Qty, cost, 0m, sourceDocType, getDocId(doc), DateTime.UtcNow, token);
+                // Serial lines consume exactly their serials' layers and can never go short; batch
+                // lines with no pinned batch are picked FEFO (docs/ITEM_TRACKING_PLAN.md Phase 3).
+                var consumed = await _fifo.ConsumeAsync(line.ItemId, line.WarehouseId, line.BatchId, line.Qty, token,
+                    // With serial numbers switched off, a serial-mode item is plain stock and may go short.
+                    allowShortfall && serials.Count == 0 && !await _serialTracking.IsSerialTrackedAsync(item, token),
+                    serials.Count > 0 ? serials.Select(s => s.SerialId).ToList() : null);
+                totalCogs += consumed.Sum(x => x.Qty * x.UnitCost);
 
-                // ConsumeAsync has no serial parameter — closing the loop on a serial-pinned
-                // line means flipping the serial's own status once its stock is actually gone.
-                if (line.SerialId.HasValue)
+                // One ledger row per batch actually issued (usually one) — a FEFO pick can span
+                // several, and each ledger row must carry the batch it moved.
+                foreach (var group in consumed.GroupBy(x => x.BatchId))
                 {
-                    var serial = await _serials.Query().FirstOrDefaultAsync(s => s.SerialId == line.SerialId, token);
-                    if (serial is not null) serial.Status = "Sold";
+                    var qty = group.Sum(x => x.Qty);
+                    var cost = qty == 0 ? 0m : group.Sum(x => x.Qty * x.UnitCost) / qty;
+                    await _fifo.PostLedgerAsync(line.ItemId, line.WarehouseId, null, group.Key,
+                        serials.Count == 1 ? serials[0].SerialId : null, _currentUser.AuditUserId,
+                        Direction.Out, qty, cost, 0m, sourceDocType, docId, now, token);
                 }
+
+                foreach (var segment in consumed)
+                {
+                    await _allocations.AddAsync(new SalesLineAllocation
+                    {
+                        SourceDocType = sourceDocType,
+                        SourceDocId = docId,
+                        SourceLineId = line.LineId,
+                        ItemId = line.ItemId,
+                        WarehouseId = line.WarehouseId,
+                        BatchId = segment.BatchId,
+                        SerialId = segment.SerialId,
+                        Qty = segment.Qty,
+                        UnitCost = segment.UnitCost,
+                        CreatedAt = now
+                    }, token);
+                }
+
+                foreach (var serial in serials)
+                {
+                    serial.Status = SerialStatus.Sold;
+                    serial.WarehouseId = null;
+                    serial.BinId = null;
+                    serial.UpdatedAt = now;
+                    await _serialMovements.AddAsync(SerialMovement.Of(serial, line.WarehouseId, sourceDocType, docId, _currentUser.AuditUserId, now), token);
+                }
+
+                await RegisterWarrantyAsync(item, line, serials, getCustomerId(doc), sourceDocType, docId, now, token);
             }
 
             setPosted(doc);
@@ -292,5 +350,78 @@ public sealed class SalesPostingService : ISalesPostingService
         }, ct);
     }
 
-    private sealed record PostingLine(int ItemId, int WarehouseId, decimal Qty, decimal PaidQty, decimal FreeQty, int? BatchId, int? SerialId);
+    /// <summary>
+    /// Re-checks a line's chosen serials at post time — the draft did not reserve them, so another
+    /// document may have sold one since — and returns them tracked for the status flip. A
+    /// serial-tracked line with none chosen may only post from pre-tracking stock (D6); the
+    /// consume call enforces that by never touching serial layers without serial ids. A bundle
+    /// line has nowhere to choose serials, so a serial item in a bundle surfaces the same way.
+    /// </summary>
+    private async Task<IReadOnlyList<Serial>> LoadSerialsForPostingAsync(Item item, PostingLine line, CancellationToken ct)
+    {
+        if (line.SerialIds.Count == 0)
+        {
+            // Same D6 rule the draft was checked against (enough serial-less stock left here),
+            // re-run because that stock may have been issued since.
+            if (item.TrackingMode == TrackingMode.Serial)
+                await _sales.ValidateLineTrackingAsync(item.ItemId, line.WarehouseId, line.Qty, null, null, new HashSet<int>(), ct);
+            return Array.Empty<Serial>();
+        }
+
+        if (line.SerialIds.Count != line.Qty)
+            throw new DomainException(ErrorCodes.TrackingRequired,
+                $"Item {item.Sku} needs exactly {line.Qty} serial number(s); {line.SerialIds.Count} are selected.", 422);
+
+        var serials = await _serials.Query().Where(s => line.SerialIds.Contains(s.SerialId)).ToListAsync(ct);
+        var unavailable = serials.Where(s => s.ItemId != item.ItemId || s.Status != SerialStatus.InStock || s.WarehouseId != line.WarehouseId)
+            .Select(s => s.SerialNo).ToList();
+        if (unavailable.Count > 0 || serials.Count != line.SerialIds.Count)
+            throw new DomainException(ErrorCodes.SerialNotAvailable,
+                $"Serial(s) {string.Join(", ", unavailable)} of item {item.Sku} are no longer in stock at this warehouse.", 409);
+        return serials;
+    }
+
+    /// <summary>
+    /// Starts the customer's warranty at posting (docs/ITEM_TRACKING_PLAN.md Phase 5): one
+    /// registration per serial, or one per line for a warranty item that is not serial-tracked.
+    /// Coverage is the period snapshotted on the serial at receipt, else the item's own.
+    /// </summary>
+    private async Task RegisterWarrantyAsync(
+        Item item, PostingLine line, IReadOnlyList<Serial> serials, int customerId,
+        string sourceDocType, int docId, DateTime now, CancellationToken ct)
+    {
+        if (item.Warranty != Warranty.Warranty) return;
+        var start = DateOnly.FromDateTime(now);
+
+        WarrantyRegistration Build(int? serialId, decimal qty, int months) => new()
+        {
+            ItemId = item.ItemId,
+            SerialId = serialId,
+            CustomerId = customerId,
+            SourceDocType = sourceDocType,
+            SourceDocId = docId,
+            SourceLineId = line.LineId,
+            Qty = qty,
+            StartDate = start,
+            PeriodMonths = months,
+            EndDate = start.AddMonths(months),
+            Status = WarrantyStatus.Active,
+            CreatedAt = now
+        };
+
+        if (serials.Count > 0)
+        {
+            foreach (var serial in serials)
+                if ((serial.WarrantyPeriodMonths ?? item.WarrantyPeriodMonths) is int months)
+                    await _warranties.AddAsync(Build(serial.SerialId, 1m, months), ct);
+            return;
+        }
+
+        if (item.WarrantyPeriodMonths is int itemMonths)
+            await _warranties.AddAsync(Build(null, line.Qty, itemMonths), ct);
+    }
+
+    private sealed record PostingLine(
+        int LineId, int ItemId, int WarehouseId, decimal Qty, decimal PaidQty, decimal FreeQty,
+        int? BatchId, IReadOnlyList<int> SerialIds);
 }
diff --git a/Backend/ERPCore/Services/SalesReturnService.cs b/Backend/ERPCore/Services/SalesReturnService.cs
index d648a63..2aba1d0 100644
--- a/Backend/ERPCore/Services/SalesReturnService.cs
+++ b/Backend/ERPCore/Services/SalesReturnService.cs
@@ -17,15 +17,24 @@ namespace ERPCore.Services;
 /// <summary>
 /// Sales-return service. Auto-posts with a mandatory Return reason code and
 /// generates an inbound stock movement via the shared <see cref="IStockMutator"/>
-/// (positive delta — creates an inbound FIFO layer at last cost). Single UoW
+/// (positive delta — creates an inbound FIFO layer). Single UoW
 /// transaction, mirroring <see cref="PurchaseReturnService"/> with the direction
 /// reversed. Also posts a real GL journal entry reversing Inventory/COGS for the
 /// stock movement's value (see <see cref="SalesReturn.GlJournalNo"/> for why revenue/tax
 /// aren't part of it) — reuses the Sales Day End accounts since that's the module
 /// whose COGS this reverses.
+/// <para>
+/// Item tracking (docs/ITEM_TRACKING_PLAN.md Phase 6): a return against an invoice line restocks
+/// into the batch(es)/serials that line actually issued (<see cref="SalesLineAllocation"/>), at
+/// the cost they were issued at; returned serials go back to InStock — or Damaged — at the return
+/// warehouse, and their warranty is voided.
+/// </para>
 /// </summary>
 public sealed class SalesReturnService : ISalesReturnService
 {
+    // Return reasons whose goods are not resaleable (see DataSeeder.StandardReasonCodes).
+    private static readonly HashSet<string> DamagedReasonCodes = new(StringComparer.OrdinalIgnoreCase) { "DEF", "QREJ" };
+
     private readonly IRepository<SalesReturn> _returns;
     private readonly IRepository<Customer> _customers;
     private readonly IRepository<Warehouse> _warehouses;
@@ -34,6 +43,12 @@ public sealed class SalesReturnService : ISalesReturnService
     private readonly IRepository<SalesInvoiceLine> _salesInvoiceLines;
     private readonly IRepository<SalesReturnLine> _returnLines;
     private readonly IRepository<StockLedger> _ledger;
+    private readonly IRepository<Batch> _batches;
+    private readonly IRepository<Serial> _serials;
+    private readonly IRepository<SalesLineAllocation> _allocations;
+    private readonly IRepository<WarrantyRegistration> _warranties;
+    private readonly IRepository<SerialMovement> _serialMovements;
+    private readonly ISerialTrackingService _serialTracking;
     private readonly IStockMutator _mutator;
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
@@ -44,7 +59,9 @@ public sealed class SalesReturnService : ISalesReturnService
     public SalesReturnService(
         IRepository<SalesReturn> returns, IRepository<Customer> customers, IRepository<Warehouse> warehouses,
         IRepository<Item> items, IRepository<ReasonCode> reasonCodes, IRepository<SalesInvoiceLine> salesInvoiceLines,
-        IRepository<SalesReturnLine> returnLines, IRepository<StockLedger> ledger, IStockMutator mutator,
+        IRepository<SalesReturnLine> returnLines, IRepository<StockLedger> ledger,
+        IRepository<Batch> batches, IRepository<Serial> serials, IRepository<SalesLineAllocation> allocations,
+        IRepository<WarrantyRegistration> warranties, IRepository<SerialMovement> serialMovements, ISerialTrackingService serialTracking, IStockMutator mutator,
         INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow,
         IGeneralLedgerService gl, IGlAccountConfigService glAccounts)
     {
@@ -56,6 +73,12 @@ public sealed class SalesReturnService : ISalesReturnService
         _salesInvoiceLines = salesInvoiceLines;
         _returnLines = returnLines;
         _ledger = ledger;
+        _batches = batches;
+        _serials = serials;
+        _allocations = allocations;
+        _warranties = warranties;
+        _serialMovements = serialMovements;
+        _serialTracking = serialTracking;
         _mutator = mutator;
         _numbers = numbers;
         _currentUser = currentUser;
@@ -91,7 +114,7 @@ public sealed class SalesReturnService : ISalesReturnService
     public async Task<SalesReturnDto?> GetAsync(int returnId, CancellationToken ct = default)
     {
         var ret = await _returns.Query().AsNoTracking()
-            .Include(r => r.Lines)
+            .Include(r => r.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(r => r.ReturnId == returnId, ct);
         if (ret is null) return null;
 
@@ -119,15 +142,19 @@ public sealed class SalesReturnService : ISalesReturnService
             ?? throw new DomainException(ErrorCodes.Validation, $"Reason code {request.ReasonCodeId} does not exist.", 422);
         if (reason.Context != ReasonContext.Return)
             throw new DomainException(ErrorCodes.Validation, $"Reason code {request.ReasonCodeId} is not a Return reason.", 422);
+        var damaged = request.MarkDamaged ?? DamagedReasonCodes.Contains(reason.Code);
 
         // Original sold qty is never mutated — "remaining returnable" is computed from
         // return history instead, so the invoice keeps recording what was actually sold.
         var pendingByInvoiceLine = new Dictionary<int, decimal>();
+        var requestSerials = new HashSet<int>();
+        var resolved = new List<ResolvedReturnLine>();
 
         foreach (var line in request.Lines)
         {
-            if (!await _items.Query().AnyAsync(i => i.ItemId == line.ItemId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+            var item = await _items.Query().AsNoTracking().FirstOrDefaultAsync(i => i.ItemId == line.ItemId, ct)
+                ?? throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+            var allocations = new List<SalesLineAllocation>();
             if (line.SalesInvoiceLineId is not null)
             {
                 var invoiceLineId = line.SalesInvoiceLineId.Value;
@@ -145,11 +172,20 @@ public sealed class SalesReturnService : ISalesReturnService
                 if (line.Qty > remaining)
                     throw new DomainException(ErrorCodes.Validation, $"Insufficient quantity — only {remaining} remain returnable on sales invoice line {invoiceLineId} (requested {line.Qty}).", 422);
                 pendingByInvoiceLine[invoiceLineId] = pending + line.Qty;
+
+                // Tracked: QtyReturned is updated below, inside the transaction.
+                allocations = await _allocations.Query()
+                    .Where(a => a.SourceDocType == DocumentTypes.SalesInvoice && a.SourceLineId == invoiceLineId)
+                    .OrderBy(a => a.SalesLineAllocationId)
+                    .ToListAsync(ct);
             }
+
+            resolved.Add(await ResolveTrackingAsync(item, line, allocations, requestSerials, ct));
         }
 
         var now = DateTime.UtcNow;
-        var deltas = request.Lines.Select(l => new StockDelta(l.ItemId, null, null, l.Qty)).ToList();
+        var deltas = resolved.Select(r => new StockDelta(
+            r.Input.ItemId, null, r.BatchId, r.Input.Qty, r.Serials.Select(s => s.SerialId).ToList(), r.UnitCost)).ToList();
 
         var (entity, ledgerEntries) = await _uow.ExecuteInTransactionAsync(async token =>
         {
@@ -163,11 +199,13 @@ public sealed class SalesReturnService : ISalesReturnService
                 Status = ReturnStatus.Posted,
                 CreatedBy = _currentUser.AuditUserId,
                 CreatedAt = now,
-                Lines = request.Lines.Select(l => new SalesReturnLine
+                Lines = resolved.Select(r => new SalesReturnLine
                 {
-                    SalesInvoiceLineId = l.SalesInvoiceLineId,
-                    ItemId = l.ItemId,
-                    Qty = l.Qty
+                    SalesInvoiceLineId = r.Input.SalesInvoiceLineId,
+                    ItemId = r.Input.ItemId,
+                    Qty = r.Input.Qty,
+                    BatchId = r.BatchId,
+                    Serials = r.Serials.Select(s => new SalesReturnLineSerial { SerialId = s.SerialId, Serial = s }).ToList()
                 }).ToList()
             };
             await _returns.AddAsync(ret, token);
@@ -175,6 +213,13 @@ public sealed class SalesReturnService : ISalesReturnService
 
             var refs = await _mutator.ApplyAsync(request.WarehouseId, DocumentTypes.SalesReturn, ret.ReturnId, now, deltas, token);
 
+            foreach (var r in resolved)
+            {
+                await ApplyReturnEffectsAsync(r, request.WarehouseId, damaged, now, token);
+                foreach (var serial in r.Serials)
+                    await _serialMovements.AddAsync(SerialMovement.Of(serial, null, DocumentTypes.SalesReturn, ret.ReturnId, _currentUser.AuditUserId, now), token);
+            }
+
             var totalValue = refs.Sum(r => r.Value);
             if (totalValue > 0)
             {
@@ -218,17 +263,182 @@ public sealed class SalesReturnService : ISalesReturnService
             .Select(g => new { SalesInvoiceLineId = g.Key, Returned = g.Sum(x => x.Qty) })
             .ToDictionaryAsync(x => x.SalesInvoiceLineId, x => x.Returned, ct);
 
+        var allocations = await _allocations.Query().AsNoTracking()
+            .Where(a => a.SourceDocType == DocumentTypes.SalesInvoice && a.SourceDocId == salesInvoiceId)
+            .Select(a => new
+            {
+                a.SourceLineId,
+                Dto = new SalesLineAllocationDto(
+                    a.BatchId, a.Batch != null ? a.Batch.BatchNo : null, a.Batch != null ? a.Batch.ExpiryDate : null,
+                    a.SerialId, a.Serial != null ? a.Serial.SerialNo : null, a.Qty, a.QtyReturned)
+            })
+            .ToListAsync(ct);
+
         return lines
             .Select(l => new SalesInvoiceLineRemainingDto(
                 l.SalesInvoiceLineId,
-                l.Qty - (returnedByLine.TryGetValue(l.SalesInvoiceLineId, out var returned) ? returned : 0m)))
+                l.Qty - (returnedByLine.TryGetValue(l.SalesInvoiceLineId, out var returned) ? returned : 0m),
+                allocations.Where(a => a.SourceLineId == l.SalesInvoiceLineId).Select(a => a.Dto).ToList()))
             .ToList();
     }
 
+    /// <summary>
+    /// Works out which batch/serials one return line restocks, and at what cost. Against an
+    /// invoice line, both must come from what that line issued; free-standing, a serial item
+    /// must name serials that are Sold and a batch item must name its batch. Legacy invoice lines
+    /// posted before allocations existed (no allocation rows) return untracked, as before.
+    /// </summary>
+    private async Task<ResolvedReturnLine> ResolveTrackingAsync(
+        Item item, CreateSalesReturnLineInput line, List<SalesLineAllocation> allocations,
+        HashSet<int> requestSerials, CancellationToken ct)
+    {
+        var serialIds = line.SerialIds?.ToList() ?? new List<int>();
+        var batchId = line.BatchId;
+        var serials = new List<Serial>();
+        var hasAllocations = allocations.Count > 0;
+
+        // Serial numbers switched off: a serial-mode item comes back as untracked stock.
+        var serialTracked = await _serialTracking.IsSerialTrackedAsync(item, ct);
+        if (!serialTracked) _serialTracking.RejectSerialsWhileDisabled(item, serialIds.Count);
+        if (!serialTracked && serialIds.Count > 0)
+            throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is not serial-tracked; serials are not accepted.", 422);
+
+        if (serialTracked)
+        {
+            var lineSoldSerials = hasAllocations && allocations.Any(a => a.SerialId != null);
+            if (serialIds.Count == 0)
+            {
+                if (line.SalesInvoiceLineId is null || lineSoldSerials)
+                    throw new DomainException(ErrorCodes.TrackingRequired,
+                        $"Item {item.Sku} is serial-tracked; select the {line.Qty} returned serial number(s).", 422);
+            }
+            else
+            {
+                if (serialIds.Count != line.Qty)
+                    throw new DomainException(ErrorCodes.TrackingRequired,
+                        $"Item {item.Sku}: returning {line.Qty} unit(s) needs exactly that many serials, got {serialIds.Count}.", 422);
+                foreach (var id in serialIds)
+                    if (!requestSerials.Add(id))
+                        throw new DomainException(ErrorCodes.SerialDuplicate, $"Serial {id} is returned more than once on this document.", 422);
+
+                serials = await _serials.Query().Where(s => serialIds.Contains(s.SerialId)).ToListAsync(ct);
+                foreach (var id in serialIds)
+                {
+                    var serial = serials.FirstOrDefault(s => s.SerialId == id);
+                    if (serial is null || serial.ItemId != item.ItemId)
+                        throw new DomainException(ErrorCodes.Validation, $"Serial {id} does not belong to item {item.Sku}.", 422);
+                    if (serial.Status != SerialStatus.Sold)
+                        throw new DomainException(ErrorCodes.SerialNotAvailable, $"Serial {serial.SerialNo} is {serial.Status}, not Sold — it cannot be returned.", 422);
+                    if (line.SalesInvoiceLineId is not null
+                        && !allocations.Any(a => a.SerialId == id && a.QtyReturned < a.Qty))
+                        throw new DomainException(ErrorCodes.SerialNotAvailable,
+                            $"Serial {serial.SerialNo} was not sold on sales invoice line {line.SalesInvoiceLineId} (or is already returned).", 422);
+                }
+                // A serial goes back into the batch it was sold from.
+                batchId ??= allocations.FirstOrDefault(a => a.SerialId == serialIds[0])?.BatchId;
+            }
+        }
+        else if (hasAllocations)
+        {
+            var issuedBatches = allocations.Where(a => a.QtyReturned < a.Qty).Select(a => a.BatchId).Distinct().ToList();
+            if (batchId is null)
+            {
+                if (issuedBatches.Count > 1)
+                    throw new DomainException(ErrorCodes.TrackingRequired,
+                        $"Sales invoice line {line.SalesInvoiceLineId} issued several batches of item {item.Sku}; choose the batch being returned.", 422);
+                batchId = issuedBatches.FirstOrDefault();
+            }
+            else if (!issuedBatches.Contains(batchId))
+            {
+                throw new DomainException(ErrorCodes.Validation,
+                    $"Batch {batchId} was not issued on sales invoice line {line.SalesInvoiceLineId}.", 422);
+            }
+        }
+        else if (item.TrackingMode == TrackingMode.Batch && batchId is null && line.SalesInvoiceLineId is null)
+        {
+            throw new DomainException(ErrorCodes.TrackingRequired, $"Item {item.Sku} is batch-tracked; choose the batch being returned.", 422);
+        }
+
+        if (batchId is not null && !await _batches.Query().AnyAsync(b => b.BatchId == batchId && b.ItemId == item.ItemId, ct))
+            throw new DomainException(ErrorCodes.Validation, $"Batch {batchId} does not belong to item {item.Sku}.", 422);
+
+        // Restock at what the goods were issued at, so the COGS reversal mirrors the sale.
+        var costed = allocations.Where(a => serials.Count > 0
+                ? a.SerialId != null && serialIds.Contains(a.SerialId.Value)
+                : a.BatchId == batchId)
+            .ToList();
+        decimal? unitCost = costed.Sum(a => a.Qty) > 0
+            ? Math.Round(costed.Sum(a => a.Qty * a.UnitCost) / costed.Sum(a => a.Qty), 6, MidpointRounding.AwayFromZero)
+            : null;
+
+        return new ResolvedReturnLine(line, item, batchId, serials, allocations, unitCost);
+    }
+
+    /// <summary>
+    /// After the stock is back: serials return to stock (or Damaged) at the return warehouse, the
+    /// issuing allocations record what came back, and the matching warranty is voided — per
+    /// serial, or reduced by the returned quantity for a non-serial warranty line.
+    /// </summary>
+    private async Task ApplyReturnEffectsAsync(ResolvedReturnLine r, int warehouseId, bool damaged, DateTime now, CancellationToken ct)
+    {
+        foreach (var serial in r.Serials)
+        {
+            serial.Status = damaged ? SerialStatus.Damaged : SerialStatus.InStock;
+            serial.WarehouseId = warehouseId;
+            serial.BinId = null;
+            serial.UpdatedAt = now;
+        }
+
+        if (r.Serials.Count > 0)
+        {
+            var ids = r.Serials.Select(s => s.SerialId).ToHashSet();
+            foreach (var a in r.Allocations.Where(a => a.SerialId != null && ids.Contains(a.SerialId.Value)))
+                a.QtyReturned = a.Qty;
+
+            var registrations = await _warranties.Query()
+                .Where(w => w.SerialId != null && ids.Contains(w.SerialId.Value) && w.Status == WarrantyStatus.Active)
+                .ToListAsync(ct);
+            foreach (var w in registrations)
+            {
+                w.Status = WarrantyStatus.Voided;
+                w.UpdatedAt = now;
+            }
+            return;
+        }
+
+        var left = r.Input.Qty;
+        foreach (var a in r.Allocations.Where(a => a.BatchId == r.BatchId && a.QtyReturned < a.Qty))
+        {
+            if (left <= 0) break;
+            var take = Math.Min(left, a.Qty - a.QtyReturned);
+            a.QtyReturned += take;
+            left -= take;
+        }
+
+        if (r.Item.Warranty == Warranty.Warranty && r.Input.SalesInvoiceLineId is int invoiceLineId)
+        {
+            var registration = await _warranties.Query()
+                .FirstOrDefaultAsync(w => w.SourceDocType == DocumentTypes.SalesInvoice && w.SourceLineId == invoiceLineId
+                    && w.SerialId == null && w.Status == WarrantyStatus.Active, ct);
+            if (registration is not null)
+            {
+                registration.Qty = Math.Max(0m, registration.Qty - r.Input.Qty);
+                if (registration.Qty == 0m) registration.Status = WarrantyStatus.Voided;
+                registration.UpdatedAt = now;
+            }
+        }
+    }
+
     private static SalesReturnDto ToDto(SalesReturn r, IReadOnlyList<int> ledgerRefs) => new(
         r.ReturnId, r.DocNo, r.CustomerId, r.WarehouseId, r.ReasonCodeId, r.Status, r.CreatedBy, r.CreatedAt,
         r.GlJournalNo, r.GlPostedAt,
         r.Lines.OrderBy(l => l.ReturnLineId)
-            .Select(l => new SalesReturnLineDto(l.ReturnLineId, l.SalesInvoiceLineId, l.ItemId, l.Qty)).ToList(),
+            .Select(l => new SalesReturnLineDto(l.ReturnLineId, l.SalesInvoiceLineId, l.ItemId, l.Qty, l.BatchId,
+                l.Serials.Select(s => new SalesLineSerialDto(s.SerialId, s.Serial?.SerialNo ?? string.Empty)).ToList()))
+            .ToList(),
         ledgerRefs);
+
+    private sealed record ResolvedReturnLine(
+        CreateSalesReturnLineInput Input, Item Item, int? BatchId, List<Serial> Serials,
+        List<SalesLineAllocation> Allocations, decimal? UnitCost);
 }
diff --git a/Backend/ERPCore/Services/SalesSlipService.cs b/Backend/ERPCore/Services/SalesSlipService.cs
index bdafaad..9e713f9 100644
--- a/Backend/ERPCore/Services/SalesSlipService.cs
+++ b/Backend/ERPCore/Services/SalesSlipService.cs
@@ -79,7 +79,7 @@ public sealed class SalesSlipService : ISalesSlipService
 
     public async Task<ETagged<SalesSlipDto>?> GetAsync(int salesSlipId, CancellationToken ct = default)
     {
-        var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines)
+        var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct);
         return slip is null ? null : new ETagged<SalesSlipDto>(_mapping.MapSlip(slip), slip.RowVersion);
     }
@@ -104,7 +104,7 @@ public sealed class SalesSlipService : ISalesSlipService
 
     public async Task<ETagged<FreeIssueDto>?> GetFreeIssueAsync(int salesSlipId, CancellationToken ct = default)
     {
-        var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines)
+        var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct);
         return slip is null ? null : new ETagged<FreeIssueDto>(MapFreeIssue(slip), slip.RowVersion);
     }
@@ -142,7 +142,7 @@ public sealed class SalesSlipService : ISalesSlipService
                 CreatedAt = DateTime.UtcNow,
                 Lines = lines
             };
-            Recalculate(entity, request.PaidAmount);
+            Recalculate(entity, request.PaidAmount, request.CardAmount);
             await _slips.AddAsync(entity, token);
             return entity;
         }, ct);
@@ -163,7 +163,7 @@ public sealed class SalesSlipService : ISalesSlipService
         slip.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
         slip.Lines.Clear();
         foreach (var line in await BuildLinesAsync(request.WarehouseId, request.Lines, ct)) slip.Lines.Add(line);
-        Recalculate(slip, request.PaidAmount);
+        Recalculate(slip, request.PaidAmount, request.CardAmount);
         slip.UpdatedAt = DateTime.UtcNow;
         try
         {
@@ -180,7 +180,7 @@ public sealed class SalesSlipService : ISalesSlipService
     public async Task<SalesSlipDto> PostAsync(int salesSlipId, CancellationToken ct = default)
         {
             await _posting.PostSlipAsync(salesSlipId, ct);
-            var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines)
+            var slip = await _slips.Query().AsNoTracking().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
                 .FirstAsync(x => x.SalesSlipId == salesSlipId, ct);
             await _notifications.RaiseAsync("sale.posted", "Sale Posted", $"Sales slip {slip.SlipNo} was posted.", nameof(SalesSlip), slip.SalesSlipId, ct);
             return _mapping.MapSlip(slip);
@@ -188,7 +188,7 @@ public sealed class SalesSlipService : ISalesSlipService
 
     public async Task<SalesSlipDto> CancelAsync(int salesSlipId, CancellationToken ct = default)
     {
-        var slip = await _slips.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct)
+        var slip = await _slips.Query().Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial).FirstOrDefaultAsync(x => x.SalesSlipId == salesSlipId, ct)
             ?? throw new NotFoundException($"Sales slip {salesSlipId} was not found.");
         if (slip.Status != SalesSlipStatus.Draft)
             throw new ConflictException($"Sales slip {salesSlipId} is {slip.Status} and cannot be cancelled.");
@@ -201,10 +201,15 @@ public sealed class SalesSlipService : ISalesSlipService
     private async Task<List<SalesSlipLine>> BuildLinesAsync(int headerWarehouseId, List<CreateSalesSlipLineRequest> requests, CancellationToken ct)
     {
         var lines = new List<SalesSlipLine>();
+        var documentSerials = new HashSet<int>();
         foreach (var r in requests)
         {
             var item = await _items.Query().AsNoTracking().FirstAsync(x => x.ItemId == r.ItemId, ct);
             await _sales.ValidateSalesLineAsync(headerWarehouseId, r.ItemId, r.WarehouseId, r.Qty, r.FreeQty, r.ParentLineId, ct);
+            // The legacy single SerialId is a one-element SerialIds.
+            var serialIds = r.SerialIds is { Count: > 0 } ? r.SerialIds
+                : r.SerialId is int single ? new List<int> { single } : null;
+            var serials = await _sales.ValidateLineTrackingAsync(r.ItemId, r.WarehouseId, r.Qty + r.FreeQty, r.BatchId, serialIds, documentSerials, ct);
             var resolved = await _sales.ResolveLinePriceAsync(r.ItemId, r.WarehouseId, r.UnitPrice, r.AllowManualPriceOverride, ct);
             var unitPrice = resolved.UnitPrice;
             var priceSource = resolved.PriceSource;
@@ -212,11 +217,6 @@ public sealed class SalesSlipService : ISalesSlipService
 
             var calc = _sales.ComputeLine(r.Qty, r.FreeQty, unitPrice, r.DiscountMode, r.DiscountPct, r.DiscountValue, r.DiscountAmount, taxPct, r.IsFreeIssue);
 
-            if (r.BatchId is not null && !await _batches.Query().AnyAsync(b => b.BatchId == r.BatchId && b.ItemId == r.ItemId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"Batch {r.BatchId} does not belong to item {r.ItemId}.", 422);
-            if (r.SerialId is not null && !await _serials.Query().AnyAsync(s => s.SerialId == r.SerialId && s.ItemId == r.ItemId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"Serial {r.SerialId} does not belong to item {r.ItemId}.", 422);
-
             lines.Add(new SalesSlipLine
             {
                 ItemId = r.ItemId,
@@ -225,7 +225,8 @@ public sealed class SalesSlipService : ISalesSlipService
                 FreeQty = r.FreeQty,
                 WarehouseId = r.WarehouseId,
                 BatchId = r.BatchId,
-                SerialId = r.SerialId,
+                SerialId = serials.Count == 1 ? serials[0].SerialId : null,
+                Serials = serials.Select(s => new SalesSlipLineSerial { SerialId = s.SerialId, Serial = s }).ToList(),
                 UnitPrice = unitPrice,
                 BaseCost = unitPrice,
                 PriceSource = priceSource,
@@ -248,9 +249,9 @@ public sealed class SalesSlipService : ISalesSlipService
     /// GrandTotal, BalanceAmount == 0) — the behavior every slip had before partial payment
     /// existed, so omitting it is a no-op change. Must be clamped against the just-recomputed
     /// GrandTotal, not the request's own line totals, since GrandTotal is only known after
-    /// lines are summed here.
+    /// lines are summed here. <paramref name="requestedCardAmount"/> null means all cash.
     /// </summary>
-    private static void Recalculate(SalesSlip slip, decimal? requestedPaidAmount)
+    private static void Recalculate(SalesSlip slip, decimal? requestedPaidAmount, decimal? requestedCardAmount)
     {
         slip.Subtotal = slip.Lines.Sum(x => x.Qty * x.UnitPrice);
         slip.DiscountTotal = slip.Lines.Sum(x => x.DiscountAmount);
@@ -262,8 +263,15 @@ public sealed class SalesSlipService : ISalesSlipService
             throw new DomainException(ErrorCodes.SalesSlipPaidAmountInvalid,
                 $"paidAmount must be between 0 and the slip's total {slip.GrandTotal}.", 400);
 
+        var card = requestedCardAmount ?? 0m;
+        if (card < 0 || card > paid)
+            throw new DomainException(ErrorCodes.SalesCardAmountInvalid,
+                $"cardAmount must be between 0 and the paid amount {paid}.", 400);
+
         slip.PaidAmount = paid;
         slip.BalanceAmount = slip.GrandTotal - paid;
+        slip.CardAmount = card;
+        slip.CashAmount = paid - card;
     }
 
     private SalesSlipSummaryDto MapSummary(SalesSlip x) => new(
@@ -319,7 +327,7 @@ public sealed class SalesSlipService : ISalesSlipService
             x.CreatedAt,
             x.UpdatedAt,
             summary,
-            x.Lines.Select(l => new SalesSlipLineDto(l.SalesSlipLineId, l.ItemId, l.Description, l.Qty, l.FreeQty, l.WarehouseId, l.UnitPrice, l.BaseCost, l.PriceSource, l.DiscountPct, l.DiscountAmount, l.DiscountMode, l.NetUnitPrice, l.LineTotal, l.TaxPct, l.TaxAmount, l.IsFreeIssue, l.ParentLineId, l.BatchId, l.SerialId)).ToList());
+            _mapping.MapSlip(x).Lines);
     }
 
     private SalesSlipDto Map(SalesSlip x) => _mapping.MapSlip(x);
diff --git a/Backend/ERPCore/Services/Stock/FifoCostingService.cs b/Backend/ERPCore/Services/Stock/FifoCostingService.cs
index d82f2a0..418a2e4 100644
--- a/Backend/ERPCore/Services/Stock/FifoCostingService.cs
+++ b/Backend/ERPCore/Services/Stock/FifoCostingService.cs
@@ -27,11 +27,13 @@ public sealed class FifoCostingService : IFifoCostingService
     private readonly ErpDbContext _db;
     private readonly IGeneralLedgerService _gl;
     private readonly IGlAccountConfigService _glAccounts;
+    private readonly LowStockTracker? _lowStock;
 
+    /// <param name="lowStock">Records each issue for the after-request low-stock check; optional so callers outside a request (tests) can omit it.</param>
     public FifoCostingService(
         IRepository<StockLayer> layers, IRepository<StockLedger> ledger,
         IRepository<JournalEntryStub> journal, ErpDbContext db,
-        IGeneralLedgerService gl, IGlAccountConfigService glAccounts)
+        IGeneralLedgerService gl, IGlAccountConfigService glAccounts, LowStockTracker? lowStock = null)
     {
         _layers = layers;
         _ledger = ledger;
@@ -39,6 +41,7 @@ public sealed class FifoCostingService : IFifoCostingService
         _db = db;
         _gl = gl;
         _glAccounts = glAccounts;
+        _lowStock = lowStock;
     }
 
     public async Task<StockLayer> CreateInboundLayerAsync(
@@ -63,11 +66,28 @@ public sealed class FifoCostingService : IFifoCostingService
 
     public async Task<IReadOnlyList<ConsumedSegment>> ConsumeAsync(
         int itemId, int warehouseId, int? batchId, decimal qtyBase, CancellationToken ct = default,
-        bool allowShortfall = false)
+        bool allowShortfall = false, IReadOnlyCollection<int>? serialIds = null)
     {
         var now = DateTime.UtcNow;
         var today = DateOnly.FromDateTime(now);
 
+        if (serialIds is not null)
+        {
+            if (serialIds.Distinct().Count() != serialIds.Count || serialIds.Count != qtyBase)
+                throw new DomainException(ErrorCodes.Validation,
+                    $"Issuing {qtyBase} of item {itemId} requires exactly {qtyBase} distinct serial(s), got {serialIds.Count}.", 422);
+            allowShortfall = false; // a serial cannot be sold before it exists
+        }
+
+        // Serial layers are held back from an issue that names no serials — but only while the
+        // item is serial-tracked and Product Configuration has serial numbers switched on. With
+        // the switch off (or the item moved off Serial), they are ordinary stock: issued
+        // oldest-first, and their serial records closed out below.
+        var holdSerialLayers = serialIds is null
+            && await _db.Items.AsNoTracking().AnyAsync(i => i.ItemId == itemId && i.TrackingMode == TrackingMode.Serial, ct)
+            && (await _db.ProductConfig.AsNoTracking().Where(c => c.ConfigId == ProductConfig.SingletonId)
+                .Select(c => (bool?)c.SerialNumbersEnabled).FirstOrDefaultAsync(ct) ?? true);
+
         if (batchId is not null)
         {
             var expiry = await _db.Batches.AsNoTracking()
@@ -107,6 +127,18 @@ public sealed class FifoCostingService : IFifoCostingService
                 """)
             .ToListAsync(ct);
 
+        // A serial item holds one layer per unit, so don't lock them all: keep only the named
+        // serials' layers (or, with none named, the untracked ones) plus shortfall layers.
+        if (candidateIds.Count > 0 && (serialIds is not null || holdSerialLayers))
+        {
+            var ids = candidateIds;
+            candidateIds = await _db.StockLayers.AsNoTracking()
+                .Where(l => ids.Contains(l.LayerId) && (l.QtyRemaining < 0 || (serialIds == null
+                    ? l.SerialId == null
+                    : l.SerialId != null && serialIds.Contains(l.SerialId.Value))))
+                .Select(l => l.LayerId).ToListAsync(ct);
+        }
+
         // `IN ()` is a syntax error, so short-circuit to the normal insufficient-stock path.
         List<StockLayer> locked;
         if (candidateIds.Count == 0)
@@ -167,11 +199,13 @@ public sealed class FifoCostingService : IFifoCostingService
         // Stock sold before it arrived is owed first: net shortfall layers off against issuable
         // stock (oldest-first) before anything new is issued, so it can't be sold twice. The
         // sale already posted its ledger Out, so settling writes no ledger entry of its own.
+        // Serial layers are excluded from settlement: netting a shortfall against one would empty
+        // a serial's layer while the serial itself still reads InStock.
         var owed = locked.Where(l => l.QtyRemaining < 0).ToList();
         var open = locked.Where(l => l.QtyRemaining > 0).ToList();
         foreach (var shortfall in owed)
         {
-            foreach (var layer in open)
+            foreach (var layer in open.Where(l => l.SerialId == null))
             {
                 if (shortfall.QtyRemaining >= 0) break;
                 var settle = Math.Min(-shortfall.QtyRemaining, layer.QtyRemaining);
@@ -182,7 +216,38 @@ public sealed class FifoCostingService : IFifoCostingService
 
         // Only now apply the caller's batch filter: settlement above is deliberately
         // batch-agnostic (a shortfall layer has no batch), but the issue itself is not.
-        var layers = open.Where(l => l.QtyRemaining > 0 && (batchId == null || l.BatchId == batchId)).ToList();
+        // Serial filter: named serials only, or — with none named — no serial layer while they
+        // are held back (see holdSerialLayers).
+        var layers = open.Where(l => l.QtyRemaining > 0 && (batchId == null || l.BatchId == batchId)
+                && (serialIds == null
+                    ? !holdSerialLayers || l.SerialId == null
+                    : l.SerialId != null && serialIds.Contains(l.SerialId.Value)))
+            .ToList();
+
+        if (serialIds is not null)
+        {
+            var found = layers.Select(l => l.SerialId!.Value).ToHashSet();
+            var missing = serialIds.Where(id => !found.Contains(id)).ToList();
+            if (missing.Count > 0)
+            {
+                var numbers = await _db.Serials.AsNoTracking().Where(s => missing.Contains(s.SerialId))
+                    .Select(s => s.SerialNo).ToListAsync(ct);
+                throw new DomainException(ErrorCodes.SerialNotAvailable,
+                    $"Serial(s) {string.Join(", ", numbers.Count > 0 ? numbers : missing.Select(m => m.ToString()))} are not available to issue from warehouse {warehouseId} (not in stock here, on hold, or expired).", 409);
+            }
+        }
+
+        // FEFO then FIFO: soonest-expiring batch first; unbatched/no-expiry stock after.
+        var layerBatchIds = layers.Where(l => l.BatchId != null).Select(l => l.BatchId!.Value).Distinct().ToList();
+        if (layerBatchIds.Count > 0)
+        {
+            var expiries = await _db.Batches.AsNoTracking().Where(b => layerBatchIds.Contains(b.BatchId))
+                .ToDictionaryAsync(b => b.BatchId, b => b.ExpiryDate, ct);
+            layers = layers
+                .OrderBy(l => l.BatchId is int b && expiries.TryGetValue(b, out var e) && e is not null ? e.Value : DateOnly.MaxValue)
+                .ThenBy(l => l.ReceiptDate).ThenBy(l => l.LayerId)
+                .ToList();
+        }
 
         var available = layers.Sum(l => l.QtyRemaining);
         if (available < qtyBase && !allowShortfall)
@@ -190,6 +255,7 @@ public sealed class FifoCostingService : IFifoCostingService
             var heldExists = await _db.StockLayers.AsNoTracking().AnyAsync(l =>
                 l.ItemId == itemId && l.WarehouseId == warehouseId && l.QtyRemaining > 0
                 && (batchId == null || l.BatchId == batchId)
+                && (serialIds == null ? l.SerialId == null : serialIds.Contains(l.SerialId ?? 0))
                 && l.GrnLine != null && (l.GrnLine.HoldStatus == HoldStatus.OnHold || l.GrnLine.HoldStatus == HoldStatus.Rejected), ct);
             if (heldExists)
                 throw new DomainException(ErrorCodes.OnHoldNotIssuable,
@@ -207,7 +273,27 @@ public sealed class FifoCostingService : IFifoCostingService
             var take = Math.Min(remaining, layer.QtyRemaining);
             layer.QtyRemaining -= take;
             remaining -= take;
-            segments.Add(new ConsumedSegment(layer.LayerId, take, layer.UnitCost));
+            segments.Add(new ConsumedSegment(layer.LayerId, take, layer.UnitCost, layer.BatchId, layer.SerialId));
+        }
+
+        // Serial units issued without being named (serial numbers switched off): close their
+        // records so the register doesn't keep showing them in stock.
+        if (serialIds is null)
+        {
+            var issuedSerialIds = layers.Where(l => l.SerialId != null && l.QtyRemaining == 0
+                    && segments.Any(s => s.LayerId == l.LayerId))
+                .Select(l => l.SerialId!.Value).ToList();
+            if (issuedSerialIds.Count > 0)
+            {
+                var issued = await _db.Serials.Where(s => issuedSerialIds.Contains(s.SerialId)).ToListAsync(ct);
+                foreach (var serial in issued)
+                {
+                    serial.Status = SerialStatus.IssuedUntracked;
+                    serial.WarehouseId = null;
+                    serial.BinId = null;
+                    serial.UpdatedAt = now;
+                }
+            }
         }
 
         // Over-stock sale: whatever stock couldn't cover becomes a negative layer (on-hand goes
@@ -229,9 +315,36 @@ public sealed class FifoCostingService : IFifoCostingService
             segments.Add(new ConsumedSegment(shortfall.LayerId, remaining, unitCost));
         }
 
+        _lowStock?.Track(itemId, warehouseId, qtyBase);
         return segments;
     }
 
+    public async Task<IReadOnlyList<BatchAllocation>> SuggestBatchesAsync(
+        int itemId, int warehouseId, decimal qtyBase, CancellationToken ct = default)
+    {
+        var today = DateOnly.FromDateTime(DateTime.UtcNow);
+        var open = await _db.StockLayers.AsNoTracking()
+            .Where(l => l.ItemId == itemId && l.WarehouseId == warehouseId && l.QtyRemaining > 0 && l.SerialId == null
+                && (l.GrnLine == null || l.GrnLine.HoldStatus == HoldStatus.Available)
+                && (l.Batch == null || l.Batch.ExpiryDate == null || l.Batch.ExpiryDate >= today))
+            .Select(l => new { l.BatchId, BatchNo = l.Batch != null ? l.Batch.BatchNo : null, Expiry = l.Batch != null ? l.Batch.ExpiryDate : null, l.ReceiptDate, l.LayerId, l.QtyRemaining })
+            .ToListAsync(ct);
+
+        var result = new List<BatchAllocation>();
+        var remaining = qtyBase;
+        foreach (var group in open
+                     .GroupBy(l => new { l.BatchId, l.BatchNo, l.Expiry })
+                     .OrderBy(g => g.Key.Expiry ?? DateOnly.MaxValue)
+                     .ThenBy(g => g.Min(l => l.ReceiptDate)))
+        {
+            if (remaining <= 0) break;
+            var take = Math.Min(remaining, group.Sum(l => l.QtyRemaining));
+            result.Add(new BatchAllocation(group.Key.BatchId, group.Key.BatchNo, group.Key.Expiry, take));
+            remaining -= take;
+        }
+        return result;
+    }
+
     // Most recent layer's cost at this warehouse, else anywhere, else 0 (never-stocked item).
     private async Task<decimal> LastKnownUnitCostAsync(int itemId, int warehouseId, CancellationToken ct)
     {
diff --git a/Backend/ERPCore/Services/Stock/ItemTrackingService.cs b/Backend/ERPCore/Services/Stock/ItemTrackingService.cs
new file mode 100644
index 0000000..53f7373
--- /dev/null
+++ b/Backend/ERPCore/Services/Stock/ItemTrackingService.cs
@@ -0,0 +1,263 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Stock;
+using ERPCore.Infra.Persistence;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services.Stock;
+
+/// <inheritdoc cref="IItemTrackingService"/>
+public sealed class ItemTrackingService : IItemTrackingService
+{
+    private readonly ErpDbContext _db;
+    private readonly IFifoCostingService _fifo;
+
+    public ItemTrackingService(ErpDbContext db, IFifoCostingService fifo)
+    {
+        _db = db;
+        _fifo = fifo;
+    }
+
+    private static DateOnly Today => DateOnly.FromDateTime(DateTime.UtcNow);
+
+    public const int MaxGeneratedSerials = 1000;
+
+    public async Task<IReadOnlyList<string>> NextSerialNumbersAsync(int itemId, string prefix, int count, CancellationToken ct = default)
+    {
+        prefix = prefix.Trim();
+        if (count < 1 || count > MaxGeneratedSerials)
+            throw new DomainException(ErrorCodes.Validation, $"Generate between 1 and {MaxGeneratedSerials} serial numbers at a time.", 422);
+        if (prefix.Length > 80)
+            throw new DomainException(ErrorCodes.Validation, "The serial prefix cannot be longer than 80 characters.", 422);
+        if (!await _db.Items.AsNoTracking().AnyAsync(i => i.ItemId == itemId, ct))
+            throw new NotFoundException($"Item {itemId} was not found.");
+
+        // Everything already taken under this prefix: received serials of the item, plus numbers
+        // sitting on draft GRN lines (they become serials when the GRN is confirmed).
+        var used = await _db.Serials.AsNoTracking()
+            .Where(s => s.ItemId == itemId && s.SerialNo.StartsWith(prefix))
+            .Select(s => s.SerialNo)
+            .Concat(_db.GrnLineSerials.AsNoTracking()
+                .Where(s => s.GrnLine!.ItemId == itemId && s.SerialId == null && s.SerialNo.StartsWith(prefix))
+                .Select(s => s.SerialNo))
+            .ToListAsync(ct);
+
+        // Highest numeric tail after the prefix ("PH-0041" → 41); width follows the widest seen.
+        long max = 0;
+        var width = 4;
+        foreach (var number in used)
+        {
+            var tail = number[prefix.Length..];
+            if (tail.Length == 0 || tail.Length > 18 || !tail.All(char.IsAsciiDigit)) continue;
+            max = Math.Max(max, long.Parse(tail));
+            width = Math.Max(width, tail.Length);
+        }
+
+        var taken = used.ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var result = new List<string>(count);
+        for (var n = max + 1; result.Count < count; n++)
+        {
+            var candidate = prefix + n.ToString().PadLeft(width, '0');
+            if (candidate.Length > 100)
+                throw new DomainException(ErrorCodes.Validation, "Generated serial numbers would exceed 100 characters — use a shorter prefix.", 422);
+            if (taken.Add(candidate)) result.Add(candidate);
+        }
+        return result;
+    }
+
+    public async Task<IReadOnlyList<AvailableSerialDto>> GetAvailableSerialsAsync(
+        int itemId, int warehouseId, string? q, int take, CancellationToken ct = default)
+    {
+        var today = Today;
+        // Issuable = InStock here AND its own layer is open, not on hold, not in an expired batch —
+        // the same test posting applies, so the picker never offers a serial posting would refuse.
+        var query = _db.StockLayers.AsNoTracking()
+            .Where(l => l.ItemId == itemId && l.WarehouseId == warehouseId && l.SerialId != null && l.QtyRemaining > 0
+                && l.Serial!.Status == SerialStatus.InStock && l.Serial.WarehouseId == warehouseId
+                && (l.GrnLine == null || l.GrnLine.HoldStatus == HoldStatus.Available)
+                && (l.Batch == null || l.Batch.ExpiryDate == null || l.Batch.ExpiryDate >= today));
+        if (!string.IsNullOrWhiteSpace(q))
+        {
+            var term = q.Trim();
+            query = query.Where(l => EF.Functions.Like(l.Serial!.SerialNo, $"%{term}%") || l.Serial.Barcode == term);
+        }
+
+        return await query
+            .OrderBy(l => l.Serial!.SerialNo)
+            .Take(Math.Clamp(take, 1, 500))
+            .Select(l => new AvailableSerialDto(l.SerialId!.Value, l.Serial!.SerialNo, l.BatchId,
+                l.Batch != null ? l.Batch.BatchNo : null, l.Serial.Status))
+            .ToListAsync(ct);
+    }
+
+    public async Task<IReadOnlyList<AvailableBatchDto>> GetAvailableBatchesAsync(int itemId, int warehouseId, CancellationToken ct = default)
+    {
+        var today = Today;
+        var rows = await _db.StockLayers.AsNoTracking()
+            .Where(l => l.ItemId == itemId && l.WarehouseId == warehouseId && l.QtyRemaining > 0 && l.SerialId == null
+                && (l.GrnLine == null || l.GrnLine.HoldStatus == HoldStatus.Available)
+                && (l.Batch == null || l.Batch.ExpiryDate == null || l.Batch.ExpiryDate >= today))
+            .GroupBy(l => new { l.BatchId, BatchNo = l.Batch != null ? l.Batch.BatchNo : null, Expiry = l.Batch != null ? l.Batch.ExpiryDate : null })
+            .Select(g => new { g.Key.BatchId, g.Key.BatchNo, g.Key.Expiry, Qty = g.Sum(l => l.QtyRemaining) })
+            .ToListAsync(ct);
+
+        return rows
+            .OrderBy(r => r.Expiry ?? DateOnly.MaxValue).ThenBy(r => r.BatchNo)
+            .Select(r => new AvailableBatchDto(r.BatchId, r.BatchNo, r.Expiry, r.Qty,
+                r.Expiry is DateOnly e ? e.DayNumber - today.DayNumber : null))
+            .ToList();
+    }
+
+    public async Task<IReadOnlyList<BatchSuggestionDto>> SuggestBatchesAsync(int itemId, int warehouseId, decimal qty, CancellationToken ct = default)
+        => (await _fifo.SuggestBatchesAsync(itemId, warehouseId, qty, ct))
+            .Select(a => new BatchSuggestionDto(a.BatchId, a.BatchNo, a.ExpiryDate, a.Qty)).ToList();
+
+    public async Task<PagedResponse<SerialSummaryDto>> ListSerialsAsync(
+        PageQuery query, int? itemId, int? warehouseId, SerialStatus? status, CancellationToken ct = default)
+    {
+        var q = _db.Serials.AsNoTracking();
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(s => EF.Functions.Like(s.SerialNo, $"%{term}%") || s.Barcode == term
+                || EF.Functions.Like(s.Item!.Sku, $"%{term}%") || EF.Functions.Like(s.Item.Name, $"%{term}%"));
+        }
+        if (itemId is not null) q = q.Where(s => s.ItemId == itemId);
+        if (warehouseId is not null) q = q.Where(s => s.WarehouseId == warehouseId);
+        if (status is not null) q = q.Where(s => s.Status == status);
+
+        var total = await q.CountAsync(ct);
+        var rows = await ProjectSerials(q.OrderByDescending(s => s.SerialId).Skip(query.Skip).Take(query.PageSize)).ToListAsync(ct);
+        return PagedResponse<SerialSummaryDto>.Create(rows, query.Page, query.PageSize, total);
+    }
+
+    public async Task<SerialDetailDto?> GetSerialAsync(int serialId, CancellationToken ct = default)
+    {
+        var serial = await ProjectSerials(_db.Serials.AsNoTracking().Where(s => s.SerialId == serialId)).FirstOrDefaultAsync(ct);
+        return serial is null ? null : await BuildDetailAsync(serial, ct);
+    }
+
+    public async Task<IReadOnlyList<SerialDetailDto>> FindSerialAsync(string serialNo, CancellationToken ct = default)
+    {
+        var term = serialNo.Trim();
+        var serials = await ProjectSerials(_db.Serials.AsNoTracking().Where(s => s.SerialNo == term || s.Barcode == term))
+            .Take(20).ToListAsync(ct);
+        var result = new List<SerialDetailDto>();
+        foreach (var s in serials) result.Add(await BuildDetailAsync(s, ct));
+        return result;
+    }
+
+    public async Task<PagedResponse<WarrantyRegistrationDto>> ListWarrantiesAsync(
+        PageQuery query, int? customerId, int? itemId, string? serialNo, WarrantyStatus? status,
+        int? expiringWithinDays, bool? expired, CancellationToken ct = default)
+    {
+        var today = Today;
+        var q = _db.WarrantyRegistrations.AsNoTracking();
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(w => (w.Serial != null && EF.Functions.Like(w.Serial.SerialNo, $"%{term}%"))
+                || EF.Functions.Like(w.Item!.Sku, $"%{term}%") || EF.Functions.Like(w.Item.Name, $"%{term}%"));
+        }
+        if (customerId is not null) q = q.Where(w => w.CustomerId == customerId);
+        if (itemId is not null) q = q.Where(w => w.ItemId == itemId);
+        if (!string.IsNullOrWhiteSpace(serialNo))
+        {
+            var term = serialNo.Trim();
+            q = q.Where(w => w.Serial != null && (w.Serial.SerialNo == term || w.Serial.Barcode == term));
+        }
+        if (status is not null) q = q.Where(w => w.Status == status);
+        if (expiringWithinDays is int days)
+        {
+            var until = today.AddDays(days);
+            q = q.Where(w => w.Status == WarrantyStatus.Active && w.EndDate >= today && w.EndDate <= until);
+        }
+        if (expired == true) q = q.Where(w => w.EndDate < today);
+        if (expired == false) q = q.Where(w => w.EndDate >= today);
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderBy(w => w.EndDate).ThenBy(w => w.WarrantyRegistrationId)
+            .Skip(query.Skip).Take(query.PageSize)
+            .Select(WarrantyProjection())
+            .ToListAsync(ct);
+        return PagedResponse<WarrantyRegistrationDto>.Create(rows.Select(r => WithDays(r, today)).ToList(), query.Page, query.PageSize, total);
+    }
+
+    public async Task<PagedResponse<BatchStockDto>> ListBatchStockAsync(
+        PageQuery query, int? itemId, int? warehouseId, int? expiringWithinDays, CancellationToken ct = default)
+    {
+        var today = Today;
+        var layers = _db.StockLayers.AsNoTracking().Where(l => l.QtyRemaining > 0 && l.BatchId != null);
+        if (itemId is not null) layers = layers.Where(l => l.ItemId == itemId);
+        if (warehouseId is not null) layers = layers.Where(l => l.WarehouseId == warehouseId);
+        if (expiringWithinDays is int days)
+        {
+            var until = today.AddDays(days);
+            layers = layers.Where(l => l.Batch!.ExpiryDate != null && l.Batch.ExpiryDate <= until);
+        }
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            layers = layers.Where(l => EF.Functions.Like(l.Batch!.BatchNo, $"%{term}%")
+                || EF.Functions.Like(l.Item!.Sku, $"%{term}%") || EF.Functions.Like(l.Item.Name, $"%{term}%"));
+        }
+
+        var grouped = layers.GroupBy(l => new
+        {
+            l.ItemId, Sku = l.Item!.Sku, ItemName = l.Item.Name,
+            l.WarehouseId, WarehouseName = l.Warehouse != null ? l.Warehouse.Name : null,
+            l.BatchId, BatchNo = l.Batch!.BatchNo, Expiry = l.Batch.ExpiryDate
+        }).Select(g => new { g.Key, Qty = g.Sum(l => l.QtyRemaining) });
+
+        var total = await grouped.CountAsync(ct);
+        var rows = await grouped
+            .OrderBy(g => g.Key.Expiry == null).ThenBy(g => g.Key.Expiry).ThenBy(g => g.Key.Sku)
+            .Skip(query.Skip).Take(query.PageSize)
+            .ToListAsync(ct);
+
+        return PagedResponse<BatchStockDto>.Create(rows.Select(r => new BatchStockDto(
+            r.Key.ItemId, r.Key.Sku, r.Key.ItemName, r.Key.WarehouseId, r.Key.WarehouseName ?? $"Warehouse {r.Key.WarehouseId}",
+            r.Key.BatchId, r.Key.BatchNo, r.Key.Expiry, r.Qty,
+            r.Key.Expiry is DateOnly e ? e.DayNumber - today.DayNumber : null,
+            r.Key.Expiry is DateOnly x && x < today)).ToList(), query.Page, query.PageSize, total);
+    }
+
+    private static IQueryable<SerialSummaryDto> ProjectSerials(IQueryable<Serial> q) => q.Select(s => new SerialSummaryDto(
+        s.SerialId, s.ItemId, s.Item!.Sku, s.Item.Name, s.SerialNo, s.Status,
+        s.WarehouseId, s.Warehouse != null ? s.Warehouse.Name : null, s.BinId, s.ReceivedAt,
+        s.GrnLine != null ? s.GrnLine.GrnId : null, s.GrnLine != null && s.GrnLine.Grn != null ? s.GrnLine.Grn.DocNo : null,
+        s.WarrantyPeriodMonths));
+
+    private async Task<SerialDetailDto> BuildDetailAsync(SerialSummaryDto serial, CancellationToken ct)
+    {
+        var today = Today;
+        var history = await _db.SerialMovements.AsNoTracking()
+            .Where(m => m.SerialId == serial.SerialId)
+            .OrderBy(m => m.SerialMovementId)
+            .Select(m => new SerialMovementDto(m.SerialMovementId, m.SourceDocType, m.SourceDocId, m.Status,
+                m.FromWarehouseId, m.WarehouseId, m.UserId, m.CreatedAt))
+            .ToListAsync(ct);
+        var warranties = await _db.WarrantyRegistrations.AsNoTracking()
+            .Where(w => w.SerialId == serial.SerialId)
+            .OrderByDescending(w => w.WarrantyRegistrationId)
+            .Select(WarrantyProjection())
+            .ToListAsync(ct);
+        return new SerialDetailDto(serial, history, warranties.Select(w => WithDays(w, today)).ToList());
+    }
+
+    private static global::System.Linq.Expressions.Expression<Func<WarrantyRegistration, WarrantyRegistrationDto>> WarrantyProjection()
+        => w => new WarrantyRegistrationDto(
+            w.WarrantyRegistrationId, w.ItemId, w.Item!.Sku, w.Item.Name, w.SerialId, w.Serial != null ? w.Serial.SerialNo : null,
+            w.CustomerId, w.Customer != null ? (w.Customer.DisplayName ?? w.Customer.Name) : string.Empty,
+            w.SourceDocType, w.SourceDocId, w.SourceLineId, w.Qty, w.StartDate, w.PeriodMonths, w.EndDate, w.Status,
+            0, false);
+
+    private static WarrantyRegistrationDto WithDays(WarrantyRegistrationDto w, DateOnly today) => w with
+    {
+        DaysRemaining = Math.Max(0, w.EndDate.DayNumber - today.DayNumber),
+        IsExpired = w.EndDate < today
+    };
+}
diff --git a/Backend/ERPCore/Services/Stock/LowStockAlertService.cs b/Backend/ERPCore/Services/Stock/LowStockAlertService.cs
new file mode 100644
index 0000000..37f9c63
--- /dev/null
+++ b/Backend/ERPCore/Services/Stock/LowStockAlertService.cs
@@ -0,0 +1,67 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services.Stock;
+
+/// <summary>
+/// Raises the <c>stock.low</c> notification when an issue takes an item's available stock at a
+/// warehouse down to or below that warehouse's reorder point (<see cref="ItemReorder"/>). Only the
+/// crossing raises it — stock that was already low doesn't alert again on every sale. Runs after
+/// the request has committed (<see cref="Infra.Filters.LowStockAlertFilter"/>), so a rolled-back
+/// document never alerts.
+/// </summary>
+public sealed class LowStockAlertService
+{
+    public const string ModuleKey = "stock.low";
+
+    private readonly LowStockTracker _tracker;
+    private readonly IRepository<ItemReorder> _reorders;
+    private readonly IStockService _stock;
+    private readonly INotificationService _notifications;
+
+    public LowStockAlertService(
+        LowStockTracker tracker, IRepository<ItemReorder> reorders, IStockService stock, INotificationService notifications)
+    {
+        _tracker = tracker;
+        _reorders = reorders;
+        _stock = stock;
+        _notifications = notifications;
+    }
+
+    public async Task CheckAsync(CancellationToken ct = default)
+    {
+        var issued = _tracker.Drain();
+        if (issued.Count == 0) return;
+
+        var itemIds = issued.Keys.Select(k => k.ItemId).Distinct().ToList();
+        var rules = await _reorders.Query().AsNoTracking()
+            .Where(r => itemIds.Contains(r.ItemId))
+            .Select(r => new
+            {
+                r.ItemId, r.WarehouseId, r.ReorderPoint, r.ReorderQty,
+                r.Item!.Sku, ItemName = r.Item.Name, Uom = r.Item.BaseUom!.Name,
+                WarehouseCode = r.Warehouse!.Code, WarehouseName = r.Warehouse.Name
+            })
+            .ToListAsync(ct);
+
+        foreach (var rule in rules)
+        {
+            if (!issued.TryGetValue((rule.ItemId, rule.WarehouseId), out var qty)) continue;
+
+            var available = (await _stock.GetOnHandAsync(rule.ItemId, rule.WarehouseId, ct)).Available;
+            var before = available + qty;
+            if (available > rule.ReorderPoint || before <= rule.ReorderPoint) continue;
+
+            await _notifications.RaiseAsync(
+                ModuleKey,
+                $"Low stock: {rule.ItemName}",
+                $"{rule.Sku} — {rule.ItemName} is down to {Qty(available)} {rule.Uom} at {rule.WarehouseCode} ({rule.WarehouseName}), "
+                    + $"at or below its alert level of {Qty(rule.ReorderPoint)}. Suggested reorder: {Qty(rule.ReorderQty)} {rule.Uom}.",
+                nameof(Item), rule.ItemId, ct);
+        }
+    }
+
+    private static string Qty(decimal value) => value.ToString("0.####");
+}
diff --git a/Backend/ERPCore/Services/Stock/LowStockTracker.cs b/Backend/ERPCore/Services/Stock/LowStockTracker.cs
new file mode 100644
index 0000000..cead6cd
--- /dev/null
+++ b/Backend/ERPCore/Services/Stock/LowStockTracker.cs
@@ -0,0 +1,27 @@
+namespace ERPCore.Services.Stock;
+
+/// <summary>
+/// Collects, for one request, every item/warehouse whose stock went down and by how much.
+/// <see cref="FifoCostingService.ConsumeAsync"/> — the one path every stock issue takes (sales,
+/// transfers, adjustments, returns, production) — records here; <see cref="LowStockAlertService"/>
+/// checks the entries against their reorder rules once the request has committed. Has no
+/// dependencies on purpose, so the FIFO service can take it without a DI cycle.
+/// </summary>
+public sealed class LowStockTracker
+{
+    private readonly Dictionary<(int ItemId, int WarehouseId), decimal> _issued = new();
+
+    public void Track(int itemId, int warehouseId, decimal qty)
+    {
+        if (qty <= 0) return;
+        _issued[(itemId, warehouseId)] = _issued.GetValueOrDefault((itemId, warehouseId)) + qty;
+    }
+
+    /// <summary>Hands back what was recorded and starts empty again.</summary>
+    public IReadOnlyDictionary<(int ItemId, int WarehouseId), decimal> Drain()
+    {
+        var copy = new Dictionary<(int ItemId, int WarehouseId), decimal>(_issued);
+        _issued.Clear();
+        return copy;
+    }
+}
diff --git a/Backend/ERPCore/Services/Stock/SerialTrackingService.cs b/Backend/ERPCore/Services/Stock/SerialTrackingService.cs
new file mode 100644
index 0000000..aad87d9
--- /dev/null
+++ b/Backend/ERPCore/Services/Stock/SerialTrackingService.cs
@@ -0,0 +1,156 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Infra.Auth;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services.Stock;
+
+/// <inheritdoc cref="ISerialTrackingService"/>
+public sealed class SerialTrackingService : ISerialTrackingService
+{
+    private readonly IRepository<Serial> _serials;
+    private readonly IRepository<SerialMovement> _movements;
+    private readonly IRepository<StockLayer> _layers;
+    private readonly IRepository<ProductConfig> _config;
+    private readonly ICurrentUser _currentUser;
+    private bool? _enabled; // per request (scoped service) — one config read
+
+    public SerialTrackingService(
+        IRepository<Serial> serials, IRepository<SerialMovement> movements,
+        IRepository<StockLayer> layers, IRepository<ProductConfig> config, ICurrentUser currentUser)
+    {
+        _serials = serials;
+        _movements = movements;
+        _layers = layers;
+        _config = config;
+        _currentUser = currentUser;
+    }
+
+    public async Task<bool> IsEnabledAsync(CancellationToken ct = default)
+        => _enabled ??= await _config.Query().AsNoTracking()
+            .Where(c => c.ConfigId == ProductConfig.SingletonId)
+            .Select(c => (bool?)c.SerialNumbersEnabled)
+            .FirstOrDefaultAsync(ct) ?? true;
+
+    public async Task<bool> IsSerialTrackedAsync(Item item, CancellationToken ct = default)
+        => item.TrackingMode == TrackingMode.Serial && await IsEnabledAsync(ct);
+
+    public void RejectSerialsWhileDisabled(Item item, int serialCount)
+    {
+        if (item.TrackingMode == TrackingMode.Serial && serialCount > 0)
+            throw new DomainException(ErrorCodes.ConfigDisabled,
+                $"Serial numbers are switched off in Product Configuration; item {item.Sku} is handled without serials.", 422);
+    }
+
+    public async Task<IReadOnlyList<Serial>> ResolveOutboundAsync(
+        Item item, int warehouseId, decimal qty, IReadOnlyCollection<int>? serialIds,
+        ISet<int> documentSerials, IReadOnlyCollection<SerialStatus> allowedStatuses, CancellationToken ct = default)
+    {
+        var ids = serialIds?.ToList() ?? new List<int>();
+        if (!await IsSerialTrackedAsync(item, ct))
+        {
+            RejectSerialsWhileDisabled(item, ids.Count);
+            if (ids.Count > 0)
+                throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is not serial-tracked; serials are not accepted.", 422);
+            return Array.Empty<Serial>();
+        }
+
+        if (ids.Count == 0)
+        {
+            var untracked = await _layers.Query().AsNoTracking()
+                .Where(l => l.ItemId == item.ItemId && l.WarehouseId == warehouseId && l.SerialId == null && l.QtyRemaining > 0)
+                .SumAsync(l => (decimal?)l.QtyRemaining, ct) ?? 0m;
+            if (untracked < qty)
+                throw new DomainException(ErrorCodes.TrackingRequired, $"Item {item.Sku} is serial-tracked; select {qty} serial number(s).", 422);
+            return Array.Empty<Serial>();
+        }
+
+        if (ids.Count != qty)
+            throw new DomainException(ErrorCodes.TrackingRequired,
+                $"Item {item.Sku}: {qty} unit(s) need exactly that many serials, got {ids.Count}.", 422);
+        foreach (var id in ids)
+            if (!documentSerials.Add(id))
+                throw new DomainException(ErrorCodes.SerialDuplicate, $"Serial {id} is used more than once on this document.", 422);
+
+        var serials = await _serials.Query().Where(s => ids.Contains(s.SerialId)).ToListAsync(ct);
+        foreach (var id in ids)
+        {
+            var serial = serials.FirstOrDefault(s => s.SerialId == id);
+            if (serial is null || serial.ItemId != item.ItemId)
+                throw new DomainException(ErrorCodes.Validation, $"Serial {id} does not belong to item {item.Sku}.", 422);
+            if (serial.WarehouseId != warehouseId || !allowedStatuses.Contains(serial.Status))
+                throw new DomainException(ErrorCodes.SerialNotAvailable,
+                    $"Serial {serial.SerialNo} is {serial.Status}{(serial.WarehouseId is int w && w != warehouseId ? $" at warehouse {w}" : string.Empty)} and cannot leave warehouse {warehouseId}.", 422);
+        }
+        return serials;
+    }
+
+    public async Task<IReadOnlyList<Serial>> ResolveInboundAsync(
+        Item item, int warehouseId, decimal qty, IReadOnlyCollection<string>? serialNos,
+        ISet<string> documentSerialNos, CancellationToken ct = default)
+    {
+        var numbers = (serialNos ?? Array.Empty<string>()).Select(n => n.Trim()).Where(n => n.Length > 0).ToList();
+        if (!await IsSerialTrackedAsync(item, ct))
+        {
+            RejectSerialsWhileDisabled(item, numbers.Count);
+            if (numbers.Count > 0)
+                throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is not serial-tracked; serial numbers are not accepted.", 422);
+            return Array.Empty<Serial>();
+        }
+
+        if (qty != decimal.Truncate(qty))
+            throw new DomainException(ErrorCodes.Validation, $"Item {item.Sku} is serial-tracked; the quantity must be a whole number.", 422);
+        if (numbers.Count != qty)
+            throw new DomainException(ErrorCodes.TrackingRequired,
+                $"Item {item.Sku} is serial-tracked; enter exactly {qty} serial number(s), got {numbers.Count}.", 422);
+        if (numbers.Any(n => n.Length > 100))
+            throw new DomainException(ErrorCodes.Validation, "A serial number cannot be longer than 100 characters.", 422);
+        foreach (var n in numbers)
+            if (!documentSerialNos.Add($"{item.ItemId}:{n.ToUpperInvariant()}"))
+                throw new DomainException(ErrorCodes.SerialDuplicate, $"Serial number {n} is entered more than once.", 422);
+
+        var existing = await _serials.Query().Where(s => s.ItemId == item.ItemId && numbers.Contains(s.SerialNo)).ToListAsync(ct);
+        var inStock = existing.Where(s => s.WarehouseId != null).Select(s => s.SerialNo).ToList();
+        if (inStock.Count > 0)
+            throw new DomainException(ErrorCodes.SerialDuplicate,
+                $"Serial number(s) {string.Join(", ", inStock)} of item {item.Sku} are already in stock.", 409);
+
+        var now = DateTime.UtcNow;
+        var result = new List<Serial>(existing);
+        foreach (var n in numbers.Where(n => !existing.Any(e => string.Equals(e.SerialNo, n, StringComparison.OrdinalIgnoreCase))))
+        {
+            var serial = new Serial
+            {
+                ItemId = item.ItemId,
+                SerialNo = n,
+                // Location is set by MoveAsync once the stock actually lands. Callers must save
+                // (flush) before building StockDeltas, which need the generated SerialId.
+                Status = SerialStatus.InStock,
+                ReceivedAt = now,
+                CreatedAt = now,
+                WarrantyPeriodMonths = item.Warranty == Warranty.Warranty ? item.WarrantyPeriodMonths : null
+            };
+            await _serials.AddAsync(serial, ct);
+            result.Add(serial);
+        }
+        return result;
+    }
+
+    public async Task MoveAsync(
+        IEnumerable<Serial> serials, SerialStatus status, int? warehouseId, int? binId,
+        string sourceDocType, int sourceDocId, DateTime now, CancellationToken ct = default)
+    {
+        foreach (var serial in serials)
+        {
+            var from = serial.WarehouseId;
+            serial.Status = status;
+            serial.WarehouseId = warehouseId;
+            serial.BinId = binId;
+            serial.UpdatedAt = now;
+            await _movements.AddAsync(SerialMovement.Of(serial, from, sourceDocType, sourceDocId, _currentUser.AuditUserId, now), ct);
+        }
+    }
+}
diff --git a/Backend/ERPCore/Services/Stock/StockMutator.cs b/Backend/ERPCore/Services/Stock/StockMutator.cs
index 7a1b9ae..4f4fae5 100644
--- a/Backend/ERPCore/Services/Stock/StockMutator.cs
+++ b/Backend/ERPCore/Services/Stock/StockMutator.cs
@@ -3,6 +3,7 @@ using ERPCore.Domain.Enums;
 using ERPCore.Infra.Auth;
 using ERPCore.Repositories.Interfaces;
 using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
 using Microsoft.EntityFrameworkCore;
 
 namespace ERPCore.Services.Stock;
@@ -41,24 +42,39 @@ public sealed class StockMutator : IStockMutator
             if (!balances.TryGetValue(d.ItemId, out var bal))
                 bal = await _fifo.GetOnHandAsync(d.ItemId, warehouseId, ct);
 
+            var serialIds = d.SerialIds is { Count: > 0 } ? d.SerialIds : null;
+            if (serialIds is not null && serialIds.Count != Math.Abs(d.QtyDelta))
+                throw new DomainException(ErrorCodes.TrackingRequired,
+                    $"Item {d.ItemId}: {Math.Abs(d.QtyDelta)} unit(s) need exactly that many serials, got {serialIds.Count}.", 422);
+            // The ledger carries a serial only when the movement is exactly one unit.
+            int? ledgerSerialId = serialIds is { Count: 1 } ? serialIds[0] : null;
+
             StockLedger entry;
             if (d.QtyDelta < 0)
             {
                 var qty = -d.QtyDelta;
-                var segments = await _fifo.ConsumeAsync(d.ItemId, warehouseId, d.BatchId, qty, ct);
+                var segments = await _fifo.ConsumeAsync(d.ItemId, warehouseId, d.BatchId, qty, ct, serialIds: serialIds);
                 var unitCost = segments.Sum(s => s.Qty * s.UnitCost) / qty;
                 bal -= qty;
                 entry = await _fifo.PostLedgerAsync(
-                    d.ItemId, warehouseId, d.BinId, d.BatchId, null, actor,
+                    d.ItemId, warehouseId, d.BinId, d.BatchId, ledgerSerialId, actor,
                     Direction.Out, qty, unitCost, bal, sourceDocType, sourceDocId, now, ct);
             }
             else
             {
-                var unitCost = await LastCostAsync(d.ItemId, warehouseId, ct);
-                await _fifo.CreateInboundLayerAsync(d.ItemId, warehouseId, d.BatchId, null, null, d.QtyDelta, unitCost, now, ct);
+                var unitCost = d.UnitCost ?? await LastCostAsync(d.ItemId, warehouseId, ct);
+                if (serialIds is not null)
+                {
+                    foreach (var serialId in serialIds)
+                        await _fifo.CreateInboundLayerAsync(d.ItemId, warehouseId, d.BatchId, serialId, null, 1m, unitCost, now, ct);
+                }
+                else
+                {
+                    await _fifo.CreateInboundLayerAsync(d.ItemId, warehouseId, d.BatchId, null, null, d.QtyDelta, unitCost, now, ct);
+                }
                 bal += d.QtyDelta;
                 entry = await _fifo.PostLedgerAsync(
-                    d.ItemId, warehouseId, d.BinId, d.BatchId, null, actor,
+                    d.ItemId, warehouseId, d.BinId, d.BatchId, ledgerSerialId, actor,
                     Direction.In, d.QtyDelta, unitCost, bal, sourceDocType, sourceDocId, now, ct);
             }
 
diff --git a/Backend/ERPCore/Services/TransferService.cs b/Backend/ERPCore/Services/TransferService.cs
index a4036c8..b3424d9 100644
--- a/Backend/ERPCore/Services/TransferService.cs
+++ b/Backend/ERPCore/Services/TransferService.cs
@@ -37,12 +37,15 @@ public sealed class TransferService : ITransferService
     private readonly IBranchConfigService _branchConfig;
     private readonly INotificationService _notifications;
     private readonly IUnitOfWork _uow;
+    private readonly ISerialTrackingService _serialTracking;
 
     public TransferService(
         IRepository<StockTransfer> transfers, IRepository<Warehouse> warehouses, IRepository<Item> items,
         IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser,
-        IBranchConfigService branchConfig, INotificationService notifications, IUnitOfWork uow)
+        IBranchConfigService branchConfig, INotificationService notifications, IUnitOfWork uow,
+        ISerialTrackingService serialTracking)
     {
+        _serialTracking = serialTracking;
         _transfers = transfers;
         _warehouses = warehouses;
         _items = items;
@@ -83,7 +86,8 @@ public sealed class TransferService : ITransferService
 
     public async Task<TransferDto?> GetAsync(int transferId, CancellationToken ct = default)
     {
-        var t = await _transfers.Query().AsNoTracking().Include(x => x.Lines)
+        var t = await _transfers.Query().AsNoTracking()
+            .Include(x => x.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(x => x.TransferId == transferId, ct);
         return t is null ? null : Map(t);
     }
@@ -95,9 +99,42 @@ public sealed class TransferService : ITransferService
         await EnsureWarehouseAsync(request.SrcWarehouseId, ct);
         await EnsureWarehouseAsync(request.DestWarehouseId, ct);
         var branchId = await _branchConfig.ResolveBranchIdAsync(request.BranchId, ct);
+
+        // Resolve tracking up front: serial lines carry their serials; a batch-tracked line with
+        // no batch is split FEFO into one line per batch, so batch identity survives the move.
+        var lines = new List<StockTransferLine>();
+        var documentSerials = new HashSet<int>();
         foreach (var line in request.Lines)
-            if (!await _items.Query().AnyAsync(i => i.ItemId == line.ItemId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+        {
+            var item = await _items.Query().AsNoTracking().FirstOrDefaultAsync(i => i.ItemId == line.ItemId, ct)
+                ?? throw new DomainException(ErrorCodes.Validation, $"Item {line.ItemId} does not exist.", 422);
+            var serials = await _serialTracking.ResolveOutboundAsync(
+                item, request.SrcWarehouseId, line.Qty, line.SerialIds, documentSerials, new[] { SerialStatus.InStock }, ct);
+
+            StockTransferLine NewLine(int? batchId, decimal qty) => new()
+            {
+                ItemId = line.ItemId,
+                SrcBinId = line.SrcBinId,
+                DestBinId = line.DestBinId,
+                BatchId = batchId,
+                Qty = qty,
+                SerialId = serials.Count == 1 ? serials[0].SerialId : null,
+                Serials = serials.Select(s => new StockTransferLineSerial { SerialId = s.SerialId }).ToList()
+            };
+
+            if (item.TrackingMode == TrackingMode.Batch && line.BatchId is null)
+            {
+                var picks = await _fifo.SuggestBatchesAsync(line.ItemId, request.SrcWarehouseId, line.Qty, ct);
+                var picked = picks.Sum(p => p.Qty);
+                foreach (var pick in picks) lines.Add(NewLine(pick.BatchId, pick.Qty));
+                // Whatever FEFO could not place stays unbatched — dispatch then reports the shortfall.
+                if (picked < line.Qty) lines.Add(NewLine(null, line.Qty - picked));
+            }
+            else
+            {
+                lines.Add(NewLine(line.BatchId, line.Qty));
+            }
+        }
 
         var actor = _currentUser.AuditUserId;
         var transfer = await _uow.ExecuteInTransactionAsync(async token =>
@@ -112,14 +149,7 @@ public sealed class TransferService : ITransferService
                 Status = TransferStatus.Draft,
                 CreatedBy = actor,
                 CreatedAt = DateTime.UtcNow,
-                Lines = request.Lines.Select(l => new StockTransferLine
-                {
-                    ItemId = l.ItemId,
-                    SrcBinId = l.SrcBinId,
-                    DestBinId = l.DestBinId,
-                    BatchId = l.BatchId,
-                    Qty = l.Qty
-                }).ToList()
+                Lines = lines
             };
             await _transfers.AddAsync(entity, token);
             return entity;
@@ -132,7 +162,8 @@ public sealed class TransferService : ITransferService
 
     public async Task<DispatchResultDto> DispatchAsync(int transferId, CancellationToken ct = default)
     {
-        var transfer = await _transfers.Query().Include(t => t.Lines)
+        var transfer = await _transfers.Query()
+            .Include(t => t.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(t => t.TransferId == transferId, ct)
             ?? throw new NotFoundException($"Transfer {transferId} was not found.");
         if (transfer.Status != TransferStatus.Draft)
@@ -148,10 +179,28 @@ public sealed class TransferService : ITransferService
         {
             foreach (var line in transfer.Lines.OrderBy(l => l.TransferLineId))
             {
-                var segments = await _fifo.ConsumeAsync(line.ItemId, transfer.SrcWarehouseId, line.BatchId, line.Qty, token);
+                // The draft didn't reserve its serials — re-check they are still here and in stock.
+                var serials = line.Serials.Select(s => s.Serial!).ToList();
+                var gone = serials.Where(s => s.Status != SerialStatus.InStock || s.WarehouseId != transfer.SrcWarehouseId).Select(s => s.SerialNo).ToList();
+                if (gone.Count > 0)
+                    throw new DomainException(ErrorCodes.SerialNotAvailable,
+                        $"Serial(s) {string.Join(", ", gone)} are no longer in stock at the source warehouse.", 409);
+
+                var segments = await _fifo.ConsumeAsync(line.ItemId, transfer.SrcWarehouseId, line.BatchId, line.Qty, token,
+                    serialIds: serials.Count > 0 ? serials.Select(s => s.SerialId).ToList() : null);
                 var value = segments.Sum(s => s.Qty * s.UnitCost);
                 line.UnitCost = value / line.Qty; // value-weighted cost, preserved to receive
 
+                // Each serial keeps its own cost and batch for its destination layer.
+                foreach (var lineSerial in line.Serials)
+                {
+                    var segment = segments.First(s => s.SerialId == lineSerial.SerialId);
+                    lineSerial.UnitCost = segment.UnitCost;
+                    lineSerial.BatchId = segment.BatchId;
+                }
+                await _serialTracking.MoveAsync(serials, SerialStatus.InTransit, null, null,
+                    DocumentTypes.Transfer, transfer.TransferId, now, token);
+
                 if (!balances.TryGetValue(line.ItemId, out var bal))
                     bal = await _fifo.GetOnHandAsync(line.ItemId, transfer.SrcWarehouseId, token);
                 bal -= line.Qty;
@@ -174,7 +223,8 @@ public sealed class TransferService : ITransferService
 
     public async Task<ReceiveResultDto> ReceiveAsync(int transferId, ReceiveTransferRequest request, CancellationToken ct = default)
     {
-        var transfer = await _transfers.Query().Include(t => t.Lines)
+        var transfer = await _transfers.Query()
+            .Include(t => t.Lines).ThenInclude(l => l.Serials).ThenInclude(s => s.Serial)
             .FirstOrDefaultAsync(t => t.TransferId == transferId, ct)
             ?? throw new NotFoundException($"Transfer {transferId} was not found.");
         if (transfer.Status != TransferStatus.InTransit)
@@ -199,9 +249,26 @@ public sealed class TransferService : ITransferService
                         $"Receiving {input.Qty} exceeds the outstanding in-transit {outstanding} on line {input.TransferLineId}.", 422);
 
                 var unitCost = line.UnitCost ?? 0m;
-                var layer = await _fifo.CreateInboundLayerAsync(
-                    line.ItemId, transfer.DestWarehouseId, line.BatchId, null, null, input.Qty, unitCost, now, token);
-                createdLayers.Add(layer);
+                if (line.Serials.Count > 0)
+                {
+                    var arriving = ResolveArrivingSerials(line, input);
+                    foreach (var lineSerial in arriving)
+                    {
+                        var layer = await _fifo.CreateInboundLayerAsync(
+                            line.ItemId, transfer.DestWarehouseId, lineSerial.BatchId ?? line.BatchId, lineSerial.SerialId, null,
+                            1m, lineSerial.UnitCost ?? unitCost, now, token);
+                        createdLayers.Add(layer);
+                        lineSerial.ReceivedAt = now;
+                    }
+                    await _serialTracking.MoveAsync(arriving.Select(s => s.Serial!), SerialStatus.InStock,
+                        transfer.DestWarehouseId, line.DestBinId, DocumentTypes.Transfer, transfer.TransferId, now, token);
+                }
+                else
+                {
+                    var layer = await _fifo.CreateInboundLayerAsync(
+                        line.ItemId, transfer.DestWarehouseId, line.BatchId, null, null, input.Qty, unitCost, now, token);
+                    createdLayers.Add(layer);
+                }
 
                 if (!balances.TryGetValue(line.ItemId, out var bal))
                     bal = await _fifo.GetOnHandAsync(line.ItemId, transfer.DestWarehouseId, token);
@@ -234,8 +301,34 @@ public sealed class TransferService : ITransferService
             throw new DomainException(ErrorCodes.Validation, $"Warehouse {warehouseId} does not exist.", 422);
     }
 
+    /// <summary>
+    /// Which in-transit serials a receive line covers: the ones it names (each still outstanding
+    /// on the line), or — with none named — every outstanding one, which must then be the full qty.
+    /// </summary>
+    private static List<StockTransferLineSerial> ResolveArrivingSerials(StockTransferLine line, ReceiveTransferLineInput input)
+    {
+        var outstanding = line.Serials.Where(s => s.ReceivedAt == null).ToList();
+        if (input.SerialIds is not { Count: > 0 })
+        {
+            if (input.Qty != outstanding.Count)
+                throw new DomainException(ErrorCodes.TrackingRequired,
+                    $"Transfer line {line.TransferLineId} is serial-tracked; name which {input.Qty} of its {outstanding.Count} in-transit serials arrived.", 422);
+            return outstanding;
+        }
+
+        if (input.SerialIds.Count != input.Qty || input.SerialIds.Distinct().Count() != input.SerialIds.Count)
+            throw new DomainException(ErrorCodes.TrackingRequired,
+                $"Receiving {input.Qty} on transfer line {line.TransferLineId} needs exactly that many distinct serials.", 422);
+        var arriving = outstanding.Where(s => input.SerialIds.Contains(s.SerialId)).ToList();
+        if (arriving.Count != input.SerialIds.Count)
+            throw new DomainException(ErrorCodes.SerialNotAvailable,
+                $"Some serials are not in transit on transfer line {line.TransferLineId}.", 422);
+        return arriving;
+    }
+
     private static TransferDto Map(StockTransfer t) => new(
         t.TransferId, t.DocNo, t.SrcWarehouseId, t.DestWarehouseId, t.BranchId, t.Status, t.CreatedBy, t.CreatedAt,
         t.Lines.OrderBy(l => l.TransferLineId).Select(l => new TransferLineDto(
-            l.TransferLineId, l.ItemId, l.SrcBinId, l.DestBinId, l.BatchId, l.Qty, l.QtyReceived)).ToList());
+            l.TransferLineId, l.ItemId, l.SrcBinId, l.DestBinId, l.BatchId, l.Qty, l.QtyReceived,
+            l.Serials.Select(s => new TransferLineSerialDto(s.SerialId, s.Serial?.SerialNo ?? string.Empty, s.ReceivedAt != null)).ToList())).ToList());
 }
diff --git a/Backend/ERPCore/Services/VendorService.cs b/Backend/ERPCore/Services/VendorService.cs
index 238865a..ca17045 100644
--- a/Backend/ERPCore/Services/VendorService.cs
+++ b/Backend/ERPCore/Services/VendorService.cs
@@ -120,6 +120,26 @@ public sealed class VendorService : IVendorService
         await _uow.SaveChangesAsync(ct);
     }
 
+    /// <summary>
+    /// Hard delete. Every FK to vendors (POs, GRNs, invoices, returns, quotations, item
+    /// default vendor) is Restrict, so a vendor in use is refused with 409 — deactivate it instead.
+    /// </summary>
+    public async Task DeleteAsync(int vendorId, CancellationToken ct = default)
+    {
+        var vendor = await _vendors.GetByIdAsync(vendorId, ct)
+            ?? throw new NotFoundException($"Vendor {vendorId} was not found.");
+
+        _vendors.Remove(vendor);
+        try
+        {
+            await _uow.SaveChangesAsync(ct);
+        }
+        catch (DbUpdateException)
+        {
+            throw new DomainException(ErrorCodes.MasterInUse, "This vendor is used by purchase documents or items and cannot be deleted. Deactivate it instead.", 409);
+        }
+    }
+
     private static VendorDto Map(Vendor v) => new(
         v.VendorId, v.Code, v.Name, v.Terms, v.TaxReg, v.Currency, v.Status, v.BranchId, v.CreatedAt, v.UpdatedAt);
 }
diff --git a/Backend/ERPCore/System/Errors/ErrorCodes.cs b/Backend/ERPCore/System/Errors/ErrorCodes.cs
index 2557cec..57297c0 100644
--- a/Backend/ERPCore/System/Errors/ErrorCodes.cs
+++ b/Backend/ERPCore/System/Errors/ErrorCodes.cs
@@ -30,6 +30,11 @@ public static class ErrorCodes
     public const string ConfigDisabled = "CONFIG_DISABLED";
     public const string RoleInUse = "ROLE_IN_USE";
 
+    // Item tracking (docs/ITEM_TRACKING_PLAN.md).
+    public const string SerialDuplicate = "SERIAL_DUPLICATE";
+    public const string SerialNotAvailable = "SERIAL_NOT_AVAILABLE";
+    public const string TrackingRequired = "TRACKING_REQUIRED";
+
     // Auth proxy (AuthController → AuthHex, docs/11 §2.0)
     public const string AuthUpstreamError = "AUTH_UPSTREAM_ERROR";
     public const string AuthServiceUnavailable = "AUTH_SERVICE_UNAVAILABLE";
@@ -88,6 +93,7 @@ public static class ErrorCodes
 
     // Sales slip partial payment (PaidAmount at ring-up time, not installments after the fact)
     public const string SalesSlipPaidAmountInvalid = "SALES_SLIP_PAID_AMOUNT_INVALID";
+    public const string SalesCardAmountInvalid = "SALES_CARD_AMOUNT_INVALID";
 
     // Purchase invoices (consolidate Confirmed GRNs; vendor payments now tracked here, not on the GRN)
     public const string GrnAlreadyInvoiced = "GRN_ALREADY_INVOICED";
@@ -99,4 +105,37 @@ public static class ErrorCodes
     public const string PurchaseInvoiceNotPayable = "PURCHASE_INVOICE_NOT_PAYABLE";
     public const string PurchaseInvoicePaymentExceedsBalance = "PURCHASE_INVOICE_PAYMENT_EXCEEDS_BALANCE";
     public const string PurchaseInvoiceBankAccountNotFound = "PURCHASE_INVOICE_BANK_ACCOUNT_NOT_FOUND";
+
+    // Expenses (docs/EXPENSE_MODULE_PLAN.md §6)
+    public const string ExpenseNotDraft = "EXPENSE_NOT_DRAFT";
+    public const string ExpenseNotPayable = "EXPENSE_NOT_PAYABLE";
+    public const string ExpensePaymentExceedsBalance = "EXPENSE_PAYMENT_EXCEEDS_BALANCE";
+    public const string ExpenseHasPayments = "EXPENSE_HAS_PAYMENTS";
+    public const string ExpenseTitleCategoryMismatch = "EXPENSE_TITLE_CATEGORY_MISMATCH";
+    public const string ExpenseTitleInactive = "EXPENSE_TITLE_INACTIVE";
+    public const string ExpenseSystemRowReadOnly = "EXPENSE_SYSTEM_ROW_READONLY";
+    public const string ExpenseBankAccountNotFound = "EXPENSE_BANK_ACCOUNT_NOT_FOUND";
+    public const string ExpenseChequeNoRequired = "EXPENSE_CHEQUE_NO_REQUIRED";
+    public const string DuplicateExpenseCategory = "DUPLICATE_EXPENSE_CATEGORY";
+    public const string DuplicateExpenseTitle = "DUPLICATE_EXPENSE_TITLE";
+
+    // Day-End Sales Report (docs/DAY_END_SALES_REPORT_PLAN.md)
+    public const string DayEndReportRangeInvalid = "DAY_END_REPORT_RANGE_INVALID";
+
+    // Bank deposits (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.4)
+    public const string BankDepositCashAccountInvalid = "BANK_DEPOSIT_CASH_ACCOUNT_INVALID";
+    public const string BankDepositBankAccountInvalid = "BANK_DEPOSIT_BANK_ACCOUNT_INVALID";
+    public const string BankDepositExceedsCashInHand = "BANK_DEPOSIT_EXCEEDS_CASH_IN_HAND";
+    public const string BankDepositDateInvalid = "BANK_DEPOSIT_DATE_INVALID";
+    public const string BankDepositNotCancellable = "BANK_DEPOSIT_NOT_CANCELLABLE";
+
+    // Dual approval (docs/DUAL_APPROVAL_PLAN.md §4.2, §6.2)
+    public const string ApprovalForbidden = "APPROVAL_FORBIDDEN";
+    public const string ApprovalSamePerson = "APPROVAL_SAME_PERSON";
+    public const string ApprovalNotPending = "APPROVAL_NOT_PENDING";
+    public const string ApprovalRoleRequired = "APPROVAL_ROLE_REQUIRED";
+    public const string ApprovalReasonRequired = "APPROVAL_REASON_REQUIRED";
+    public const string PriceAdjustmentItemPending = "PRICE_ADJUSTMENT_ITEM_PENDING";
+    public const string PriceAdjustmentStale = "PRICE_ADJUSTMENT_STALE";
+    public const string PriceChangeRequiresApproval = "PRICE_CHANGE_REQUIRES_APPROVAL";
 }
diff --git a/Backend/ERPCore/appsettings.Development.json b/Backend/ERPCore/appsettings.Development.json
index c80290e..fb17e25 100644
--- a/Backend/ERPCore/appsettings.Development.json
+++ b/Backend/ERPCore/appsettings.Development.json
@@ -10,5 +10,8 @@
   },
   "AuthHex": {
     "BaseUrl": "http://localhost:5011"
+  },
+  "GeneralLedgerService": {
+    "BaseUrl": "https://localhost:7024/api/v1/"
   }
 }
diff --git a/Backend/ERPCore/appsettings.json b/Backend/ERPCore/appsettings.json
index b5c8f51..ec012c5 100644
--- a/Backend/ERPCore/appsettings.json
+++ b/Backend/ERPCore/appsettings.json
@@ -49,6 +49,16 @@
   "SalesInvoice": {
     "GlAccountsReceivableCode": "1300"
   },
+  "DayEndReport": {
+    "TimeZone": "Asia/Colombo"
+  },
+  "Expense": {
+    "GlAccruedExpensesCode": "2300"
+  },
+  "BankDeposit": {
+    "DefaultCashAccountCode": "1000-01",
+    "CashTrackingStartDate": "2026-10-01"
+  },
   "PurchaseInvoice": {
     "GlClearingAccountCode": "2000",
     "GlAccountsPayableCode": "2200"
diff --git a/Backend/PROGRESS.md b/Backend/PROGRESS.md
index b80f704..7216d65 100644
--- a/Backend/PROGRESS.md
+++ b/Backend/PROGRESS.md
@@ -4,6 +4,114 @@ Legend: `[ ]` not started · `[~]` in progress · `[x]` done
 Spec: `docs/10-BACKEND-PHASE1.md` (model + rules) · `docs/11-BACKEND-PHASE1.md` (API)
 Convention: `docs/01-DOC-GUIDE.md §6`. Update this file in the **same commit** as the code. When ticking `[x]`, append a short note + any deviation.
 
+## Dual approval — stock & price adjustments (2026-10-12) — `docs/DUAL_APPROVAL_PLAN.md`
+
+- [x] **Approval engine** — `IApprovalService`/`ApprovalService`: maker–checker rules in one place (requester can't
+  approve `APPROVAL_FORBIDDEN`; the two approvers must differ `APPROVAL_SAME_PERSON`; optional level-2 roles
+  `APPROVAL_ROLE_REQUIRED`; reject needs a reason `APPROVAL_REASON_REQUIRED`; no Admin bypass). One `DocumentApproval`
+  row per decision (`document_approvals`, polymorphic `DocType` ADJ/PADJ + `DocId`). `ApprovalConfig` singleton
+  (`approval_config`, seeded 2/2): levels 0/1/2 per document, a value (LKR) / percent threshold below which two levels
+  drop to one, `Level2RoleCodes`. Approvers are Admins plus roles with the Approve action on the screen's NAV code.
+  `INotificationService.NotifyUsersAsync` (targeted, same InApp gate) + modules `approval.pending/approved/rejected`.
+- [x] **Stock adjustments** — `AdjustmentStatus` + `PendingSecondApproval`, `Rejected`, `Cancelled` (column widened to 30).
+  `CreateAsync` validates as before (reason, items, serials) then saves a **request**; stock, ledger, serial moves and the
+  GL journal happen in `PostInCurrentTransactionAsync` on the final approval, re-validated then (negative stock / moved
+  serials fail the approval, the request stays pending). Requested serials are kept as JSON on the line
+  (`RequestedSerialIds/Nos`) and new serials are only created at posting. Levels 0 = posts on create (old behaviour).
+  Value for the threshold = |qty| × average FIFO cost. Endpoints `POST /stock-adjustments/{id}/approve|reject|cancel`
+  (approve/reject need `stock.adjustments` Approve), `status` filter on the list. Wastage uses the same path.
+- [x] **Stock counts** — `CountService.PostAsync` now submits its variances through `AdjustmentService.SubmitAsync`
+  (closing the count in the same transaction), so a count is not a way around approval. Its own copy of the posting/GL
+  code is gone. **Deviation:** serial moves for count variances are recorded against the adjustment, not the count.
+- [x] **Price adjustments** — `PriceAdjustment` (`PADJ-…`), `PriceAdjustmentLine` (old snapshot + new min/max/flat),
+  `ItemPriceHistory`. Rules: one pending request per item (`PRICE_ADJUSTMENT_ITEM_PENDING`), min ≤ flat ≤ max, at least
+  one change; on final approval the item must still have the snapshot prices (`PRICE_ADJUSTMENT_STALE`), then prices are
+  written and a history row added. `PriceAdjustmentsController` (`/api/v1/price-adjustments` + `GET /items/{id}/price-history`).
+  `ItemService.UpdateAsync` refuses a price change while price approval is on (`PRICE_CHANGE_REQUIRES_APPROVAL`); prices
+  set on item **create** need no approval.
+- [x] **Inbox & settings** — `ApprovalsController`: `GET /approvals/pending` (what you can approve + your own requests,
+  actionable count), `GET/PUT /approvals/config` (PUT needs `settings.approvals`).
+- [x] **Migration `AddDualApproval`** — tables, columns, seeds (sub-nav 48 `products.price-adjustments`, 49
+  `settings.approvals`; permissions 58/59), grants 58 to Admin + roles with Products (2/11), 59 to Admin, turns the three
+  approval notifications on. Existing adjustments keep `RequiredApprovals = 0` (posted without approval). **Not yet applied**.
+- [x] **Tests** — `DualApprovalTests` (20 incl. theories): pending-until-approved, two different approvers, own-request and
+  same-person refusals, reject with reason, levels 0, value threshold, withdraw, level-2 roles, price apply + history, stale
+  price, one pending request per item. Suite 86/86.
+
+## Bank Deposit module (2026-10-08) — `docs/BANK_DEPOSIT_MODULE_PLAN.md`
+
+- [x] **Cash in hand** — `ICashInHandService`/`CashInHandService`: till cash per branch and business day. In = slip/bundle
+  `CashAmount` + cash invoice payments (any invoice); out = cash expense payments (expense not Cancelled); Posted deposits
+  reduce it by `BusinessDate`. Closing carries to the next day from `BankDeposit:CashTrackingStartDate` (appsettings,
+  `2026-10-01`); the opening before a window is a few DB `SUM`s. "Available to deposit" = lowest closing from that day
+  to today, so a back-dated deposit can't overdraw a later day. `BusinessDayClock` (singleton) now holds the
+  `DayEndReport:TimeZone` day ↔ UTC helpers for both this and the report.
+- [x] **Entity + migration `AddBankDepositModule`** — `BankDeposit` (`bank_deposits`, branch query filter, `CHECK Amount > 0`,
+  index `(BranchId, BusinessDate, Status)`), enum `BankDepositStatus` (Posted/Cancelled, no draft), doc type `BD`.
+  Seeds sub-nav `accounts.bank-deposits` (SubNavItemId 47, SortOrder 6) + permission 57, granted (Actions 31) to Admin and
+  every role holding an Accounts permission (26/32/33/34/54). **Not yet applied** — applies on next startup (`MigrateAsync`).
+- [x] **API** — `BankDepositsController` (`/api/v1/bank-deposits`): list (business-date range, branch, bank account, status;
+  returns `totalAmount` of all matching rows), get, `cash-in-hand?date&branchId`, `cash-in-hand/daily?from&to` (≤ 92 days),
+  create, `{id}/cancel`. **Deviation from plan §6:** one `NAV:accounts.bank-deposits` permission with action suffixes
+  (create = `Create`, cancel = `Delete`) instead of three permission codes — the project's RBAC is one NAV code per screen.
+- [x] **GL** — create: Dr bank account / Cr cash account (`BANK_DEPOSIT`, entry date = deposit date), posted before commit.
+  Cancel: reversing entry dated today. From must be a GL `Cash` account, to a `Bank` account. The balance check runs
+  inside the transaction after `SELECT … FOR UPDATE` on the branch row, so concurrent deposits for one branch serialize.
+  With branching off, cash is measured across all branches (everything sits on the default branch).
+- [x] **Day-End Report** — cash figures now come from `ICashInHandService`; day rows add `openingCashInHand`,
+  `cashDeposited`, `closingCashInHand` (range totals: first opening, summed deposits, last closing); the day adds
+  `deposits[]`. `NetCash` unchanged.
+- [x] **Tests** — `CashInHandServiceTests` (7), `BankDepositServiceTests` (14 incl. theories), plus a deposit case in
+  `DayEndReportServiceTests`. Suite: 59/59 passing.
+
+## Day-End Sales Report (2026-10-08) — `docs/DAY_END_SALES_REPORT_PLAN.md`
+
+- [x] **Payment method on sales** — enum `SalesPaymentMethod` (Cash/Card/BankTransfer/Cheque). `SalesInvoicePayment.PaymentMethod`
+  (request field optional on single and bulk payments; omitted ⇒ derived from the account: Cash account ⇒ Cash, Bank ⇒ Card).
+  `SalesSlip` and `BundleSale` gain `CashAmount`/`CardAmount` (request `cardAmount`, optional, rest is cash; error
+  `SALES_CARD_AMOUNT_INVALID`). **Deviation:** the UI only creates invoices, so the cash/card split that matters is the
+  per-payment method; the slip/bundle fields exist for API callers.
+- [x] **Migration `AddSalesPaymentMethodsAndDayEndReport`** — columns above; backfills slips/bundles as all cash and
+  invoice payments as Cash (column default); seeds sub-nav `sales.day-end-report` (SubNavItemId 46) + permission 56 and
+  grants it to Admin and every role holding `NAV:sales.day-end` (52). **Not yet applied** — applies on next startup
+  (`MigrateAsync`).
+- [x] **API** — `DayEndReportController` (`GET /api/v1/day-end-report?date&branchId`, `GET /api/v1/day-end-report/daily?from&to&branchId`,
+  ≤ 92 days, `DAY_END_REPORT_RANGE_INVALID`). `DayEndReportService`: Posted slips + bundles + invoices; Paid split by
+  method; counts cash/card/mixed/other/unpaid; Posted expenses by `ExpenseDate`; Income = sales − expenses; plus
+  collections on earlier invoices and net cash (till check). Days are `DayEndReport:TimeZone` (appsettings,
+  `Asia/Colombo`) calendar days. **Deviations:** sales returns are not netted off income — `SalesReturnLine` carries
+  no price; rows are bucketed by local day in memory (slim DB projections) since MariaDB can't group by a zone-shifted
+  date portably. Non-admins are forced to their own branch.
+- [x] **Sales list + profit/loss** (2026-10-08) — the day response adds `sales[]` (doc type/no., time, customer, total,
+  paid, due, paid-by, cost, gross profit) and every day row adds `costOfGoodsSold` (stock ledger Out value per sale
+  document — same source as `SalesDayEndService`'s COGS), `grossProfit` (sales − cost) and `netProfit` (gross − expenses;
+  negative = loss).
+- [x] **Tests** — `ERPCore.Tests/DayEndReportServiceTests.cs` (mixed documents and methods, cancelled expense excluded,
+  time-zone boundary, earlier-invoice collection + net cash, unpaid invoice, zero-filled days, range validation).
+
+- [x] **Entities + migration `AddExpenseModule`** — `ExpenseCategory`, `ExpenseTitle`, `Expense`, `ExpensePayment`
+  (`Domain/Entities/ExpenseCategory.cs`, `Expense.cs`), enums in `Domain/Enums/ExpenseStatus.cs`. Seeds 4 system
+  categories (Utility/Rental/Salaries/Other) + 18 system titles with **placeholder** GL codes 6100/6200/6300/6900
+  (`ExpenseConfiguration.cs`). `Expense` is branch-scoped (global query filter) and numbered `EXP-…` per branch.
+- [x] **Nav/permissions** — sub-items `accounts.expenses` (SubNavItemId 44) and `accounts.expense-setup` (45),
+  permissions 54/55. **Deviation from the plan:** ids 23/24 were already taken.
+- [x] **API** — `ExpensesController` (`/api/v1/expenses`, list/summary/get/create/update/delete/post/post-and-pay/cancel/payments)
+  and `ExpenseSetupController` (`/api/v1/expense-categories`, `/api/v1/expense-titles`). Reading the setup lists needs
+  only `accounts`; changing them needs `accounts.expense-setup`.
+- [x] **GL** — Post: Dr title's account / Cr `Expense:GlAccruedExpensesCode` (appsettings, placeholder `2300`).
+  Payment: Dr Accrued / Cr each cash-bank account. Cancel of a Posted expense with no payments posts the reversal.
+  All GL calls happen before commit (same pattern as `PurchaseInvoicePaymentService`). **Deviations:** a payment
+  submission may carry several lines (split cash/bank) and posts **one** journal shared by its payment rows; the
+  per-category default GL codes live in the seed, not in appsettings (config can't feed `HasData`); a Draft can also
+  be cancelled (no GL entry). Post & Pay accepts a full or partial payment (changed 2026-10-08; it first
+  required the full amount). The remainder stays as the balance.
+- [x] **Migrations applied to dev DB** (2026-10-08): `AddExpenseModule`, `GrantExpensePermissions` (grants 54/55 to
+  Admin and to every role that already reaches Accounts; without it no role had the codes in `/auth/me`, so the
+  sidebar hid the screens), `UpdateExpenseGlCodes`.
+- [x] **GL accounts created in the dev GL** (2026-10-08): the placeholder 6100 failed with "Account 6100 not found",
+  and GL generates codes itself. Created `2300` Accrued Expenses and `5200` Operating Expenses (control) with
+  `5200-01..04` (Utilities, Rent, Salaries & Wages, Other Expenses). The seeded titles now use those codes.
+
 ## Per-variant content size (2026-08-11) — follow-up to the UOM re-model below
 
 The UOM re-model put `ContentQty`/`ContentUnit` on `Item` correctly, but the item **create page
diff --git a/Frontend/PROGRESS.md b/Frontend/PROGRESS.md
index 627db79..0ac6d5a 100644
--- a/Frontend/PROGRESS.md
+++ b/Frontend/PROGRESS.md
@@ -4,6 +4,68 @@ Legend: `[ ]` not started · `[~]` in progress · `[x]` done
 Spec: `docs/20-FRONTEND.md` (flows + rules) · `docs/11-BACKEND-PHASE1.md` (API contract)
 Convention: `docs/01-DOC-GUIDE.md §6`. Update this file in the **same commit** as the code. When ticking `[x]`, append a short note + any deviation.
 
+## Dual approval — stock & price adjustments (2026-10-12) — `docs/DUAL_APPROVAL_PLAN.md`
+
+- [x] **Approvals inbox** (`app/dashboard/approvals`, sidebar entry for everyone with a badge of actionable requests):
+  "Waiting for you" (Approve / Approve & apply / Reject with reason) and "Waiting for others" (your own requests, with why).
+- [x] **Stock → Adjustments**: status filter, rows open the new detail page `adjustments/[id]` (lines, requested serials,
+  approval timeline, Approve / Reject / Withdraw via `components/approvals/ApprovalPanel.tsx`). New adjustment, Wastage and
+  Count post now say "submitted for approval" with a link when the result is pending. Wastage list hides rejected/withdrawn
+  requests and tags pending ones. `AdjustmentStatusBadge` covers the new statuses.
+- [x] **Products → Price Adjustments** (list, `new` — add items, edit new min/max/flat from the current prices, reason —
+  and `[id]` with old → new, a stale-request warning and the approval panel). Item page: selling prices read-only in Edit
+  while price approval is on, "Request price change" links, and a Price history panel.
+- [x] **Settings → Approvals** (`app/dashboard/settings/approvals`): levels per document, thresholds, level-2 roles.
+- [x] Types `types/approvals.ts`, API `lib/api/approvals.ts`; `lib/api/stock-adjustments.ts` gains approve/reject/cancel.
+  `tsc` clean; no new lint errors (the setState-in-effect errors in touched pages were already there).
+
+## Bank Deposit module (2026-10-08) — `docs/BANK_DEPOSIT_MODULE_PLAN.md`
+
+- [x] **Accounts → Bank Deposits** (`app/dashboard/accounts/bank-deposits`): list (search, status, business-date range,
+  bank-account filter, server total in the footer, CSV export) with a "Cash in hand by day" view (opening, cash in,
+  cash out, deposited, closing; the filter's range capped at 92 days, default last 30). Cards: deposited (filtered),
+  cash in hand now, net cash today. Admins' header branch switcher is sent as `branchId` (totals are server-side).
+- [x] `new/`: branch (admins), business date, deposit date, from cash account (preselects `defaultCashAccountCode`),
+  to bank account, amount (defaults to "available to deposit", blocked above it), slip no., depositor, remarks; a cash
+  position panel beside it. `[id]/`: details + cancel with reason (reverses GL). `lib/api/bank-deposits.ts`,
+  `types/bank-deposits.ts`, `components/accounts/bank-deposit-badges.tsx`. Sidebar + Accounts hub card added.
+- [x] **Day-End Report**: the one-line "Net cash in hand" became a Cash in hand group (opening, net cash today,
+  deposited to bank, remaining — amber while > 0) with the day's deposits table; the daily table adds Deposited and
+  Cash in hand columns. PDFs: single day adds the cash block + deposits; day-wise adds a separate "Cash in hand and bank
+  deposits" table. **Deviation:** not two more columns on the day-wise PDF table — A4 portrait is already full at 9 columns.
+
+## Day-End Sales Report (2026-10-08) — `docs/DAY_END_SALES_REPORT_PLAN.md`
+
+- [x] Sales payment method: `PaymentLinesEditor` takes optional `methodOptions`/`methodForAccount` and shows a Method column
+  (picking a Cash account sets Cash, a Bank account sets Card; changeable). Used by `SalesInvoicePaymentDialog` and
+  `SalesInvoiceBulkPaymentDialog` only — the expense/purchase dialogs are unchanged. Types in `types/sales.ts`, `types/bundles.ts`.
+- [x] **Sales → Day-End Report** (`app/dashboard/sales/day-end-report`): business-date picker, sales/payment/count cards,
+  Income card (sales − expenses), the day's expenses, and a day-wise section (from/to, default last 30 days) with an
+  income/sales/expenses line chart (`components/sales/DayEndIncomeChart.tsx`) and a daily table with totals (click a
+  row to open that day). Admins follow the header branch switcher. `lib/api/day-end-report.ts`.
+- [x] PDFs (`lib/pdf/day-end-report-pdf.ts`): day-wise income (totals, chart, paginated daily table + totals row) and
+  single day (figures, counts, expense list). **Deviation:** tables drawn with plain `jspdf` instead of adding
+  `jspdf-autotable`; the chart is rendered offscreen in light colours for print.
+- [x] Sidebar entry (`sales.day-end-report`) and header title.
+- [x] **Sales table + profit/loss** (2026-10-08): the day view lists every sale (time, no., type, customer, paid by, total,
+  paid, due, cost, profit; invoices link to their page) and ends with a statement — sales − cost of goods sold = gross
+  profit − expenses = **Net profit** (green) or **Net loss** (red, shown as a positive amount labelled Loss;
+  `profitOrLoss()` in `lib/format.ts`). Day-wise table, chart and both PDFs gain a Profit / loss column/line.
+
+- [x] `types/expenses.ts`, `lib/api/expenses.ts` (`expensesApi`, `expenseSetupApi`).
+- [x] **Accounts → Expenses** (`app/dashboard/accounts/expenses`): list with period summary cards (posted, unpaid,
+  outstanding, overdue), by-category breakdown, filters (status tabs, payment status incl. Overdue, category → title,
+  date range, search), CSV export of all pages, row Post / Pay / Post & Pay. `new`, `[id]` (detail, payments, cancel
+  with reason, delete draft) and `[id]/edit` (Draft only), sharing `components/accounts/ExpenseForm.tsx`.
+  "Save & pay" lands on the detail page with `?pay=1`, which opens the payment dialog once.
+- [x] `components/accounts/ExpensePaymentDialog.tsx` reuses `PaymentLinesEditor` (split across cash/bank accounts) plus
+  payment method and cheque no. A Draft goes through the single-transaction `post-and-pay` endpoint, unlike
+  `PurchaseInvoicePaymentDialog`'s post-then-pay-per-line loop.
+- [x] **Accounts → Expense Setup** (`app/dashboard/accounts/expense-setup`): categories → titles, add category/title,
+  edit (built-in names locked), GL code per title, activate/deactivate. Shows the Salaries/payroll double-count warning
+  (plan §10 Q4). The expense form has an inline "Add title" for users with `accounts.expense-setup`.
+- [x] Sidebar (`AppSidebar.tsx`), header titles (`Header.tsx`) and the Accounts hub page list the two new screens.
+
 ## 0. Foundation
 - [x] **Transport: same-origin Next `rewrites()` proxy** (`next.config.ts`, `/api/*` → `BACKEND_ORIGIN`, default `http://localhost:5224`). `BACKEND_ORIGIN` in `.env.local` / `.env.local.example` — **not** `NEXT_PUBLIC_*`; the browser never sees the backend URL. Chosen over backend CORS because it makes the API same-origin, so CORS and the Secure/SameSite=Strict session cookies stop being problems at all. (`.gitignore`'s `.env*` was silently swallowing the example file — added a `!.env.local.example` negation.)
 - [x] **Typed API client rebuilt** (`lib/api-client.ts`, 2026-07-17) — recovered the pre-deletion version from git (`0e4bcf1^`) and adapted: relative `/api/v1` base, **`credentials: "include"`** (never present before), `ApiResult`/`ProblemDetails` imported from `@/types/common` rather than redeclared, `readCsrfToken()` for the eight `[ValidateCsrf]` auth actions. `ApiError`, `apiRequest`, `apiRequestWithETag`, `buildQuery`, `ifMatch`/`idempotencyKey` all carried over.
diff --git a/Frontend/erp-system/app/apple-icon.png b/Frontend/erp-system/app/apple-icon.png
new file mode 100644
index 0000000..b6caa7b
Binary files /dev/null and b/Frontend/erp-system/app/apple-icon.png differ
diff --git a/Frontend/erp-system/app/dashboard/accounts/bank-deposits/[id]/page.tsx b/Frontend/erp-system/app/dashboard/accounts/bank-deposits/[id]/page.tsx
new file mode 100644
index 0000000..9a48ff1
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/bank-deposits/[id]/page.tsx
@@ -0,0 +1,190 @@
+"use client"
+
+import { use, useEffect, useState } from "react"
+import Link from "next/link"
+import { ArrowLeft, Ban } from "lucide-react"
+
+import { bankDepositsApi } from "@/lib/api/bank-deposits"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { BankDeposit } from "@/types/bank-deposits"
+
+import { BankDepositStatusBadge } from "@/components/accounts/bank-deposit-badges"
+import { Button } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldLabel } from "@/components/ui/field"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Textarea } from "@/components/ui/textarea"
+import { toast } from "@/components/ui/toast"
+
+export default function BankDepositDetailPage({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = use(params)
+  const bankDepositId = Number(id)
+
+  const [deposit, setDeposit] = useState<BankDeposit | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const error = Number.isFinite(bankDepositId) ? loadError : `Invalid deposit id '${id}'.`
+  const [cancelOpen, setCancelOpen] = useState(false)
+  const [cancelReason, setCancelReason] = useState("")
+  const [cancelError, setCancelError] = useState<string | null>(null)
+  const [cancelling, setCancelling] = useState(false)
+
+  useEffect(() => {
+    if (!Number.isFinite(bankDepositId)) return
+    bankDepositsApi
+      .get(bankDepositId)
+      .then(setDeposit)
+      .catch((err) => setLoadError(errorMessage(err)))
+  }, [bankDepositId])
+
+  async function handleCancel() {
+    if (!deposit) return
+    if (!cancelReason.trim()) {
+      setCancelError("Enter a reason")
+      return
+    }
+    setCancelling(true)
+    try {
+      const cancelled = await bankDepositsApi.cancel(deposit.bankDepositId, cancelReason.trim())
+      setDeposit(cancelled)
+      setCancelOpen(false)
+      toast.success("Deposit cancelled", `Reversing journal ${cancelled.glReversalJournalNo ?? "—"} — the cash is back in hand.`)
+    } catch (err) {
+      setCancelError(errorMessage(err))
+    } finally {
+      setCancelling(false)
+    }
+  }
+
+  if (error) {
+    return (
+      <div className="flex flex-col gap-4">
+        <BackLink />
+        <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+      </div>
+    )
+  }
+  if (!deposit) return <Skeleton className="h-96 w-full" />
+
+  return (
+    <div className="flex flex-col gap-6">
+      <BackLink />
+
+      <div className="flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between">
+        <div className="flex flex-col gap-2">
+          <div className="flex flex-wrap items-center gap-3">
+            <h1 className="text-2xl font-bold text-foreground">{deposit.docNo}</h1>
+            <BankDepositStatusBadge status={deposit.status} />
+          </div>
+          <p className="text-base text-muted-foreground">
+            Cash of {formatReportDate(deposit.businessDate)} deposited to {deposit.toBankAccountName}
+          </p>
+        </div>
+
+        {deposit.status === "Posted" && (
+          <Button
+            variant="outline"
+            onClick={() => {
+              setCancelReason("")
+              setCancelError(null)
+              setCancelOpen(true)
+            }}
+          >
+            <Ban className="size-4" />
+            Cancel deposit
+          </Button>
+        )}
+      </div>
+
+      <div className="grid grid-cols-1 gap-3 sm:grid-cols-3">
+        <div className="rounded-xl border bg-card p-4 shadow-sm">
+          <p className="text-sm text-muted-foreground">Amount</p>
+          <p className={cn("text-xl font-bold tabular-nums", deposit.status === "Cancelled" ? "text-muted-foreground line-through" : "text-foreground")}>
+            {formatAmount(deposit.amount)}
+          </p>
+        </div>
+        <div className="rounded-xl border bg-card p-4 shadow-sm">
+          <p className="text-sm text-muted-foreground">From</p>
+          <p className="font-semibold text-foreground">{deposit.fromCashAccountName}</p>
+          <p className="text-xs text-muted-foreground">GL {deposit.fromCashAccountCode}</p>
+        </div>
+        <div className="rounded-xl border bg-card p-4 shadow-sm">
+          <p className="text-sm text-muted-foreground">To</p>
+          <p className="font-semibold text-foreground">{deposit.toBankAccountName}</p>
+          <p className="text-xs text-muted-foreground">
+            {[deposit.toBankName, deposit.toAccountNumber, `GL ${deposit.toBankAccountCode}`].filter(Boolean).join(" · ")}
+          </p>
+        </div>
+      </div>
+
+      <div className="rounded-2xl border bg-card p-4 shadow-sm sm:p-6">
+        <dl className="grid grid-cols-1 gap-x-6 gap-y-4 text-sm sm:grid-cols-2 lg:grid-cols-3">
+          <Detail label="Business date" value={formatReportDate(deposit.businessDate)} />
+          <Detail label="Deposit date" value={formatReportDate(deposit.depositDate)} />
+          <Detail label="Branch" value={deposit.branchName ?? `#${deposit.branchId}`} />
+          <Detail label="Deposit slip no." value={deposit.depositSlipNo ?? "—"} />
+          <Detail label="Deposited by" value={deposit.depositedBy ?? "—"} />
+          <Detail label="Recorded" value={formatReportDate(deposit.createdAt)} />
+          <Detail label="Ledger journal" value={deposit.glJournalNo ?? "—"} />
+          {deposit.status === "Cancelled" && (
+            <>
+              <Detail label="Reversal journal" value={deposit.glReversalJournalNo ?? "—"} />
+              <Detail label="Cancelled" value={formatReportDate(deposit.cancelledAt)} />
+              <Detail label="Cancel reason" value={deposit.cancelReason ?? "—"} />
+            </>
+          )}
+          {deposit.remarks && (
+            <div className="sm:col-span-2 lg:col-span-3">
+              <dt className="text-muted-foreground">Remarks</dt>
+              <dd className="mt-0.5 whitespace-pre-wrap text-foreground">{deposit.remarks}</dd>
+            </div>
+          )}
+        </dl>
+      </div>
+
+      <Dialog open={cancelOpen} onOpenChange={setCancelOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Cancel deposit {deposit.docNo}</DialogTitle>
+          </DialogHeader>
+          <p className="text-sm text-muted-foreground">
+            A reversing journal entry will be posted (cash up, bank down) and {formatAmount(deposit.amount)} goes back into the cash in hand
+            for {formatReportDate(deposit.businessDate)}. This cannot be undone — record a new deposit if it was only entered wrongly.
+          </p>
+          <Field data-invalid={!!cancelError}>
+            <FieldLabel htmlFor="bd-cancel-reason" required>Reason</FieldLabel>
+            <Textarea id="bd-cancel-reason" value={cancelReason} maxLength={250} rows={3} onChange={(e) => setCancelReason(e.target.value)} />
+            <FieldError errors={[cancelError ? { message: cancelError } : undefined]} />
+          </Field>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setCancelOpen(false)} disabled={cancelling}>
+              Keep it
+            </Button>
+            <Button variant="destructive" onClick={handleCancel} disabled={cancelling}>
+              {cancelling ? "Cancelling…" : "Cancel deposit"}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  )
+}
+
+function BackLink() {
+  return (
+    <Link href="/dashboard/accounts/bank-deposits" className="inline-flex w-fit items-center gap-1.5 text-sm font-medium text-muted-foreground hover:text-foreground">
+      <ArrowLeft className="size-4" />
+      Bank Deposits
+    </Link>
+  )
+}
+
+function Detail({ label, value }: { label: string; value: string }) {
+  return (
+    <div>
+      <dt className="text-muted-foreground">{label}</dt>
+      <dd className="mt-0.5 font-medium text-foreground">{value}</dd>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/bank-deposits/new/page.tsx b/Frontend/erp-system/app/dashboard/accounts/bank-deposits/new/page.tsx
new file mode 100644
index 0000000..65123fe
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/bank-deposits/new/page.tsx
@@ -0,0 +1,414 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import Link from "next/link"
+import { useRouter } from "next/navigation"
+import { ArrowLeft } from "lucide-react"
+
+import { bankDepositsApi } from "@/lib/api/bank-deposits"
+import { bankAccountsApi } from "@/lib/api/general-ledger"
+import { branchesHrmApi } from "@/lib/api/hrm-masters"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { CashInHand, CreateBankDepositRequest, maskAccountNumber } from "@/types/bank-deposits"
+import { CashAndBankAccountDto, CashBankAccountType } from "@/types/general-ledger"
+import { Branch } from "@/types/hrm"
+
+import { useAuth } from "@/components/auth/AuthProvider"
+import { localToday } from "@/components/sales/PaymentLinesEditor"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { Field, FieldDescription, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Textarea } from "@/components/ui/textarea"
+import { toast } from "@/components/ui/toast"
+
+type Errors = Partial<Record<"branch" | "businessDate" | "depositDate" | "from" | "to" | "amount", string>>
+
+function addDays(iso: string, days: number) {
+  const d = new Date(`${iso}T00:00:00`)
+  d.setDate(d.getDate() + days)
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
+}
+
+/** Record till cash taken to the bank: pick the day, see its cash position, choose the cash and bank accounts. */
+export default function NewBankDepositPage() {
+  const router = useRouter()
+  const { isAdmin, loading: authLoading, branchId: myBranchId, activeBranchId, activeBranchName, branchingEnabled } = useAuth()
+  const today = localToday()
+
+  const [branches, setBranches] = useState<Branch[]>([])
+  const [accounts, setAccounts] = useState<CashAndBankAccountDto[] | null>(null)
+  const [accountsError, setAccountsError] = useState<string | null>(null)
+  const [position, setPosition] = useState<CashInHand | null>(null)
+  const [positionError, setPositionError] = useState<string | null>(null)
+
+  const [branchPickId, setBranchPickId] = useState<number | null>(null)
+  const [businessDate, setBusinessDate] = useState(today)
+  const [depositDate, setDepositDate] = useState(today)
+  const [fromAccountId, setFromAccountId] = useState<number | null>(null)
+  const [toAccountId, setToAccountId] = useState<number | null>(null)
+  const [amount, setAmount] = useState("")
+  const [amountTouched, setAmountTouched] = useState(false)
+  const [depositSlipNo, setDepositSlipNo] = useState("")
+  const [depositedBy, setDepositedBy] = useState("")
+  const [remarks, setRemarks] = useState("")
+  const [errors, setErrors] = useState<Errors>({})
+  const [saving, setSaving] = useState(false)
+
+  // Same branch rules as the Expense form: a branch user is always their own branch; an admin uses the
+  // header's branch, or picks one here. With branching off the server uses the single default branch.
+  const lockedBranchId = isAdmin ? activeBranchId : myBranchId
+  const showBranchPicker = branchingEnabled && isAdmin && !lockedBranchId
+  const effectiveBranchId = branchingEnabled ? (isAdmin ? (activeBranchId ?? branchPickId) : myBranchId) : null
+  const needsBranch = branchingEnabled && isAdmin && effectiveBranchId === null
+
+  const cashAccounts = accounts?.filter((a) => a.accountType === CashBankAccountType.Cash) ?? []
+  const bankAccounts = accounts?.filter((a) => a.accountType === CashBankAccountType.Bank) ?? []
+
+  useEffect(() => {
+    if (branchingEnabled && isAdmin) branchesHrmApi.list({ pageSize: 200, status: "Active" }).then((r) => setBranches(r.items)).catch(() => setBranches([]))
+  }, [branchingEnabled, isAdmin])
+
+  useEffect(() => {
+    if (accounts !== null) return
+    bankAccountsApi
+      .list("Both")
+      .then((rows) => {
+        setAccounts(rows)
+        setAccountsError(null)
+      })
+      .catch((err) => {
+        setAccounts([])
+        setAccountsError(errorMessage(err))
+      })
+  }, [accounts])
+
+  useEffect(() => {
+    if (authLoading || needsBranch || !businessDate) return
+    let stale = false
+    bankDepositsApi
+      .cashInHand({ date: businessDate, branchId: effectiveBranchId })
+      .then((res) => {
+        if (stale) return
+        setPosition(res)
+        setPositionError(null)
+      })
+      .catch((err) => {
+        if (stale) return
+        setPosition(null)
+        setPositionError(errorMessage(err))
+      })
+    return () => {
+      stale = true
+    }
+  }, [authLoading, needsBranch, businessDate, effectiveBranchId])
+
+  // Preselect the configured cash account (and the only bank account, when there is just one).
+  const defaultCashCode = position?.defaultCashAccountCode ?? null
+  if (fromAccountId === null && cashAccounts.length > 0) {
+    const preferred = cashAccounts.find((a) => a.glAccountCode === defaultCashCode) ?? (cashAccounts.length === 1 ? cashAccounts[0] : null)
+    if (preferred) setFromAccountId(preferred.accountId)
+  }
+  if (toAccountId === null && bankAccounts.length === 1) setToAccountId(bankAccounts[0].accountId)
+
+  // The amount follows what is available until the user types their own.
+  const available = position?.availableToDeposit ?? 0
+  const suggested = position ? available.toFixed(2) : ""
+  if (!amountTouched && amount !== suggested) setAmount(suggested)
+
+  function changeBusinessDate(value: string) {
+    setBusinessDate(value)
+    // Deposit date follows the business date unless it would fall before it.
+    if (!depositDate || depositDate < value) setDepositDate(value)
+  }
+
+  function validate(): Errors {
+    const next: Errors = {}
+    const value = Number(amount)
+    if (needsBranch) next.branch = "Select the branch whose cash is being deposited"
+    if (!businessDate) next.businessDate = "Select the business date"
+    else if (businessDate > today) next.businessDate = "The business date cannot be in the future"
+    else if (position?.trackingStartDate && businessDate < position.trackingStartDate)
+      next.businessDate = `Cash in hand is tracked from ${formatReportDate(position.trackingStartDate)}`
+    if (!depositDate) next.depositDate = "Select the deposit date"
+    else if (businessDate && depositDate < businessDate) next.depositDate = "Cannot be before the business date"
+    else if (depositDate > addDays(today, 1)) next.depositDate = "Cannot be in the future"
+    if (!fromAccountId) next.from = "Select the cash account the money leaves"
+    if (!toAccountId) next.to = "Select the bank account it goes into"
+    if (!amount || Number.isNaN(value) || value <= 0) next.amount = "Enter an amount greater than zero"
+    else if (position && value > available + 0.0001) next.amount = `Only ${formatAmount(available)} is available to deposit for this day`
+    return next
+  }
+
+  async function submit() {
+    const nextErrors = validate()
+    setErrors(nextErrors)
+    if (Object.keys(nextErrors).length > 0) return
+
+    const request: CreateBankDepositRequest = {
+      branchId: effectiveBranchId ?? 0,
+      businessDate,
+      depositDate,
+      amount: Number(amount),
+      fromGlCashAccountId: fromAccountId!,
+      toGlBankAccountId: toAccountId!,
+      depositSlipNo: depositSlipNo.trim() || undefined,
+      depositedBy: depositedBy.trim() || undefined,
+      remarks: remarks.trim() || undefined,
+    }
+
+    setSaving(true)
+    try {
+      const saved = await bankDepositsApi.create(request)
+      toast.success("Deposit recorded", `${saved.docNo} — ${formatAmount(saved.amount)} to ${saved.toBankAccountName} (journal ${saved.glJournalNo ?? "—"})`)
+      router.push(`/dashboard/accounts/bank-deposits/${saved.bankDepositId}`)
+    } catch (err) {
+      toast.error("Could not record the deposit", errorMessage(err))
+      setSaving(false)
+    }
+  }
+
+  if (authLoading) return <Skeleton className="h-96 w-full" />
+
+  return (
+    <div className="flex flex-col gap-6">
+      <Link href="/dashboard/accounts/bank-deposits" className="inline-flex w-fit items-center gap-1.5 text-sm font-medium text-muted-foreground hover:text-foreground">
+        <ArrowLeft className="size-4" />
+        Bank Deposits
+      </Link>
+
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">New Bank Deposit</h1>
+        <p className="text-base text-muted-foreground">
+          Deposit the day’s till cash to a bank account. It is posted to the ledger straight away (bank up, cash down).
+        </p>
+      </div>
+
+      <div className="grid grid-cols-1 gap-6 lg:grid-cols-[1fr_20rem]">
+        <div className="rounded-2xl border bg-card p-4 shadow-sm sm:p-6">
+          <FieldGroup>
+            <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+              {branchingEnabled && isAdmin && (
+                <Field data-invalid={!!errors.branch}>
+                  <FieldLabel required>Branch</FieldLabel>
+                  {showBranchPicker ? (
+                    <Select<number | null> value={branchPickId} onValueChange={(v) => setBranchPickId(v)}>
+                      <SelectTrigger className="h-11! w-full text-base" aria-invalid={!!errors.branch}>
+                        <SelectValue placeholder="Select branch" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {branches.map((b) => (
+                          <SelectItem key={b.branchId} value={b.branchId} className="text-base">
+                            {b.name}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  ) : (
+                    <div className="flex h-11 items-center rounded-lg border border-input bg-muted px-3 text-base text-muted-foreground">
+                      {activeBranchName ?? `Branch #${lockedBranchId}`}
+                    </div>
+                  )}
+                  <FieldError errors={[errors.branch ? { message: errors.branch } : undefined]} />
+                </Field>
+              )}
+
+              <Field data-invalid={!!errors.businessDate}>
+                <FieldLabel htmlFor="bd-business-date" required>Business date</FieldLabel>
+                <Input
+                  id="bd-business-date"
+                  type="date"
+                  max={today}
+                  min={position?.trackingStartDate ?? undefined}
+                  value={businessDate}
+                  onChange={(e) => changeBusinessDate(e.target.value)}
+                  aria-invalid={!!errors.businessDate}
+                />
+                <FieldDescription>The day whose cash is being deposited.</FieldDescription>
+                <FieldError errors={[errors.businessDate ? { message: errors.businessDate } : undefined]} />
+              </Field>
+
+              <Field data-invalid={!!errors.depositDate}>
+                <FieldLabel htmlFor="bd-deposit-date" required>Deposit date</FieldLabel>
+                <Input
+                  id="bd-deposit-date"
+                  type="date"
+                  min={businessDate || undefined}
+                  max={addDays(today, 1)}
+                  value={depositDate}
+                  onChange={(e) => setDepositDate(e.target.value)}
+                  aria-invalid={!!errors.depositDate}
+                />
+                <FieldDescription>When the bank received it — also the ledger entry date.</FieldDescription>
+                <FieldError errors={[errors.depositDate ? { message: errors.depositDate } : undefined]} />
+              </Field>
+            </div>
+
+            {accountsError && (
+              <div className="flex items-center justify-between gap-3 rounded-lg border border-destructive/30 bg-destructive/5 p-3 text-sm text-destructive">
+                <span>Could not load cash/bank accounts from the ledger: {accountsError}</span>
+                <Button type="button" size="sm" variant="outline" onClick={() => setAccounts(null)}>
+                  Retry
+                </Button>
+              </div>
+            )}
+
+            <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+              <Field data-invalid={!!errors.from}>
+                <FieldLabel htmlFor="bd-from" required>From cash account</FieldLabel>
+                <Select<number | null> value={fromAccountId} onValueChange={(v) => setFromAccountId(v)}>
+                  <SelectTrigger id="bd-from" className="h-11! w-full text-base" aria-invalid={!!errors.from}>
+                    <SelectValue placeholder={accounts === null ? "Loading…" : "Select cash account"} />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {cashAccounts.map((a) => (
+                      <SelectItem key={a.accountId} value={a.accountId} className="text-base">
+                        {a.accountName} <span className="text-muted-foreground">({a.glAccountCode})</span>
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+                {accounts !== null && cashAccounts.length === 0 && !accountsError && (
+                  <FieldDescription>No cash accounts in the ledger — add one under Accounts → Cash / Bank Accounts.</FieldDescription>
+                )}
+                <FieldError errors={[errors.from ? { message: errors.from } : undefined]} />
+              </Field>
+
+              <Field data-invalid={!!errors.to}>
+                <FieldLabel htmlFor="bd-to" required>To bank account</FieldLabel>
+                <Select<number | null> value={toAccountId} onValueChange={(v) => setToAccountId(v)}>
+                  <SelectTrigger id="bd-to" className="h-11! w-full text-base" aria-invalid={!!errors.to}>
+                    <SelectValue placeholder={accounts === null ? "Loading…" : "Select bank account"} />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {bankAccounts.map((a) => (
+                      <SelectItem key={a.accountId} value={a.accountId} className="text-base">
+                        {a.accountName}
+                        <span className="text-muted-foreground">
+                          {" "}
+                          {[a.bankName, maskAccountNumber(a.accountNumber)].filter(Boolean).join(" · ")}
+                        </span>
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+                {accounts !== null && bankAccounts.length === 0 && !accountsError && (
+                  <FieldDescription>No bank accounts in the ledger — add one under Accounts → Cash / Bank Accounts.</FieldDescription>
+                )}
+                <FieldError errors={[errors.to ? { message: errors.to } : undefined]} />
+              </Field>
+            </div>
+
+            <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+              <Field data-invalid={!!errors.amount}>
+                <FieldLabel htmlFor="bd-amount" required>Amount</FieldLabel>
+                <Input
+                  id="bd-amount"
+                  type="number"
+                  inputMode="decimal"
+                  min="0"
+                  step="0.01"
+                  value={amount}
+                  onChange={(e) => {
+                    setAmountTouched(true)
+                    setAmount(e.target.value)
+                  }}
+                  aria-invalid={!!errors.amount}
+                  className="text-base tabular-nums"
+                />
+                <FieldDescription>
+                  Defaults to everything available.
+                  {amountTouched && position && (
+                    <>
+                      {" "}
+                      <button type="button" className="font-medium text-primary hover:underline" onClick={() => setAmountTouched(false)}>
+                        Use {formatAmount(available)}
+                      </button>
+                    </>
+                  )}
+                </FieldDescription>
+                <FieldError errors={[errors.amount ? { message: errors.amount } : undefined]} />
+              </Field>
+
+              <Field>
+                <FieldLabel htmlFor="bd-slip">Deposit slip no. (optional)</FieldLabel>
+                <Input id="bd-slip" value={depositSlipNo} maxLength={50} onChange={(e) => setDepositSlipNo(e.target.value)} />
+              </Field>
+
+              <Field>
+                <FieldLabel htmlFor="bd-by">Deposited by (optional)</FieldLabel>
+                <Input id="bd-by" value={depositedBy} maxLength={150} onChange={(e) => setDepositedBy(e.target.value)} />
+              </Field>
+            </div>
+
+            <Field>
+              <FieldLabel htmlFor="bd-remarks">Remarks (optional)</FieldLabel>
+              <Textarea id="bd-remarks" value={remarks} maxLength={500} rows={2} onChange={(e) => setRemarks(e.target.value)} />
+            </Field>
+          </FieldGroup>
+
+          <div className="mt-6 flex flex-col-reverse gap-2 sm:flex-row sm:justify-end">
+            <Link href="/dashboard/accounts/bank-deposits" className={cn(buttonVariants({ variant: "outline", size: "lg" }))}>
+              Cancel
+            </Link>
+            <Button size="lg" onClick={submit} disabled={saving || needsBranch}>
+              {saving ? "Recording…" : "Record deposit"}
+            </Button>
+          </div>
+        </div>
+
+        <CashPositionPanel position={position} error={positionError} needsBranch={needsBranch} />
+      </div>
+    </div>
+  )
+}
+
+function CashPositionPanel({ position, error, needsBranch }: { position: CashInHand | null; error: string | null; needsBranch: boolean }) {
+  return (
+    <aside className="flex h-fit flex-col gap-3 rounded-2xl border bg-card p-4 shadow-sm sm:p-6">
+      <h2 className="text-base font-semibold text-foreground">Cash position</h2>
+      {needsBranch ? (
+        <p className="text-sm text-muted-foreground">Select a branch to see its cash in hand.</p>
+      ) : error ? (
+        <p className="text-sm text-destructive">{error}</p>
+      ) : !position ? (
+        <Skeleton className="h-48 w-full" />
+      ) : (
+        <>
+          <p className="text-sm text-muted-foreground">{formatReportDate(position.position.date)}</p>
+          <dl className="flex flex-col gap-2 text-sm">
+            <Row label="Opening cash in hand" value={position.position.opening} />
+            <Row label="Cash in" value={position.position.cashIn} />
+            <Row label="Cash out (expenses)" value={-position.position.cashOut} />
+            <Row label="Already deposited" value={-position.position.deposited} />
+            <div className="border-t pt-2">
+              <Row label="Cash in hand" value={position.position.closing} strong />
+            </div>
+          </dl>
+          <div className="rounded-xl bg-primary/10 p-3">
+            <p className="text-sm text-muted-foreground">Available to deposit</p>
+            <p className="text-2xl font-bold tabular-nums text-primary">{formatAmount(position.availableToDeposit)}</p>
+            {position.availableToDeposit < position.position.closing && (
+              <p className="mt-1 text-xs text-muted-foreground">Lower than the day’s cash in hand: later days have already banked part of it.</p>
+            )}
+          </div>
+          {position.trackingStartDate && (
+            <p className="text-xs text-muted-foreground">Cash in hand is counted from {formatReportDate(position.trackingStartDate)}.</p>
+          )}
+        </>
+      )}
+    </aside>
+  )
+}
+
+function Row({ label, value, strong }: { label: string; value: number; strong?: boolean }) {
+  return (
+    <div className="flex items-center justify-between gap-3">
+      <dt className={cn(strong ? "font-semibold text-foreground" : "text-muted-foreground")}>{label}</dt>
+      <dd className={cn("tabular-nums", strong ? "font-bold text-foreground" : "font-medium text-foreground")}>{formatAmount(value)}</dd>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/bank-deposits/page.tsx b/Frontend/erp-system/app/dashboard/accounts/bank-deposits/page.tsx
new file mode 100644
index 0000000..e7c7e14
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/bank-deposits/page.tsx
@@ -0,0 +1,545 @@
+"use client"
+
+import { useEffect, useMemo, useState } from "react"
+import Link from "next/link"
+import { useRouter } from "next/navigation"
+import { CalendarDays, Coins, Download, FileText, Landmark, PiggyBank, Plus, Wallet } from "lucide-react"
+
+import { bankDepositsApi } from "@/lib/api/bank-deposits"
+import { bankAccountsApi } from "@/lib/api/general-ledger"
+import { downloadCsv } from "@/lib/csv-export"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { PaginationMeta } from "@/types/common"
+import { CashAndBankAccountDto, CashBankAccountType } from "@/types/general-ledger"
+import {
+  BankDeposit,
+  BankDepositListFilterParams,
+  BankDepositStatus,
+  CashInHand,
+  CashInHandDaily,
+  maskAccountNumber,
+} from "@/types/bank-deposits"
+
+import { useAuth } from "@/components/auth/AuthProvider"
+import { BankDepositStatusBadge } from "@/components/accounts/bank-deposit-badges"
+import { Badge } from "@/components/ui/badge"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { DateRangePicker } from "@/components/ui/date-picker"
+import { Field, FieldLabel } from "@/components/ui/field"
+import { FilterBar } from "@/components/ui/filter-bar"
+import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { StatCard } from "@/components/ui/stat-card"
+import { Table, TableBody, TableCell, TableFooter, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { toast } from "@/components/ui/toast"
+
+type View = "deposits" | "cash"
+type StatusFilter = BankDepositStatus | "All"
+type DateRange = "Month" | "Today" | "7d" | "30d" | "All" | "Custom"
+type CustomRange = { from: Date | undefined; to?: Date | undefined }
+
+const statusOptions: { value: StatusFilter; label: string }[] = [
+  { value: "All", label: "All statuses" },
+  { value: "Posted", label: "Posted" },
+  { value: "Cancelled", label: "Cancelled" },
+]
+const dateRanges: { value: DateRange; label: string }[] = [
+  { value: "Month", label: "This month" },
+  { value: "Today", label: "Today" },
+  { value: "7d", label: "7 days" },
+  { value: "30d", label: "30 days" },
+  { value: "All", label: "All time" },
+  { value: "Custom", label: "Custom range" },
+]
+
+const PAGE_SIZE_OPTIONS = [5, 10, 15, 20]
+/** The cash-in-hand endpoint serves at most 92 days. */
+const MAX_CASH_DAYS = 92
+
+function toIsoDate(d: Date) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
+}
+
+function addDays(iso: string, days: number) {
+  const d = new Date(`${iso}T00:00:00`)
+  d.setDate(d.getDate() + days)
+  return toIsoDate(d)
+}
+
+/** Inclusive business-date bounds ending today, as on the Expenses list. */
+function dateRangeBounds(range: DateRange, custom: CustomRange | undefined): { from?: string; to?: string } {
+  const today = new Date()
+  if (range === "Custom") {
+    if (!custom?.from) return {}
+    return { from: toIsoDate(custom.from), to: toIsoDate(custom.to ?? custom.from) }
+  }
+  if (range === "All") return {}
+  if (range === "Month") return { from: toIsoDate(new Date(today.getFullYear(), today.getMonth(), 1)), to: toIsoDate(today) }
+  const days = range === "Today" ? 1 : range === "7d" ? 7 : 30
+  const from = new Date(today)
+  from.setDate(today.getDate() - (days - 1))
+  return { from: toIsoDate(from), to: toIsoDate(today) }
+}
+
+/** The cash view needs a bounded window: the filter's, else the last 30 days; never over 92 days (keeps the end). */
+function cashWindow(from: string | undefined, to: string | undefined): { from: string; to: string } {
+  const end = to ?? toIsoDate(new Date())
+  let start = from ?? addDays(end, -29)
+  if (addDays(start, MAX_CASH_DAYS - 1) < end) start = addDays(end, -(MAX_CASH_DAYS - 1))
+  return { from: start, to: end }
+}
+
+function bankLabel(d: { toBankAccountName: string; toBankName: string | null; toAccountNumber: string | null }) {
+  return [d.toBankName, maskAccountNumber(d.toAccountNumber)].filter(Boolean).join(" · ")
+}
+
+export default function BankDepositsPage() {
+  const router = useRouter()
+  const { isAdmin, activeBranchId, branchingEnabled } = useAuth()
+
+  const [view, setView] = useState<View>("deposits")
+  const [rows, setRows] = useState<BankDeposit[] | null>(null)
+  const [pagination, setPagination] = useState<PaginationMeta | null>(null)
+  const [totalAmount, setTotalAmount] = useState(0)
+  const [error, setError] = useState<string | null>(null)
+  const [loadingMore, setLoadingMore] = useState(false)
+  const [bankAccounts, setBankAccounts] = useState<CashAndBankAccountDto[]>([])
+  const [todayCash, setTodayCash] = useState<CashInHand | null>(null)
+  const [daily, setDaily] = useState<CashInHandDaily | null>(null)
+  const [dailyError, setDailyError] = useState<string | null>(null)
+
+  const [status, setStatus] = useState<StatusFilter>("All")
+  const [bankAccountId, setBankAccountId] = useState<number | null>(null)
+  const [dateRange, setDateRange] = useState<DateRange>("Month")
+  const [customRange, setCustomRange] = useState<CustomRange | undefined>(undefined)
+  const { from, to } = dateRangeBounds(dateRange, customRange)
+  const [searchInput, setSearchInput] = useState("")
+  const [query, setQuery] = useState("")
+  const [rowsPerPage, setRowsPerPage] = useState(PAGE_SIZE_OPTIONS[1])
+  const [exporting, setExporting] = useState(false)
+
+  // Admins bypass branch scoping server-side, so the header's branch switcher is sent as the filter
+  // (the totals come from the server, so filtering client-side would leave them wrong).
+  const branchId = isAdmin && branchingEnabled ? activeBranchId : null
+  const showBranch = isAdmin && branchingEnabled && !activeBranchId
+
+  useEffect(() => {
+    bankAccountsApi.list(CashBankAccountType.Bank).then(setBankAccounts).catch(() => setBankAccounts([]))
+  }, [])
+
+  useEffect(() => {
+    const timeout = setTimeout(() => setQuery(searchInput.trim()), 300)
+    return () => clearTimeout(timeout)
+  }, [searchInput])
+
+  const filters: BankDepositListFilterParams = useMemo(
+    () => ({
+      q: query || undefined,
+      status: status === "All" ? undefined : status,
+      bankAccountId: bankAccountId ?? undefined,
+      branchId: branchId ?? undefined,
+      from,
+      to,
+    }),
+    [query, status, bankAccountId, branchId, from, to]
+  )
+
+  const pagingKey = `${JSON.stringify(filters)}|${rowsPerPage}`
+  const [paging, setPaging] = useState({ key: "", page: 1, pageSize: rowsPerPage })
+  const { page, pageSize } = paging.key === pagingKey ? paging : { page: 1, pageSize: rowsPerPage }
+  const setPage = (p: number) => setPaging({ key: pagingKey, page: p, pageSize })
+
+  useEffect(() => {
+    bankDepositsApi
+      .list({ ...filters, page, pageSize })
+      .then((res) => {
+        setError(null)
+        setRows(res.items)
+        setPagination(res.pagination)
+        setTotalAmount(res.totalAmount)
+      })
+      .catch((err) => setError(errorMessage(err)))
+      .finally(() => setLoadingMore(false))
+  }, [filters, page, pageSize])
+
+  useEffect(() => {
+    bankDepositsApi.cashInHand({ branchId }).then(setTodayCash).catch(() => setTodayCash(null))
+  }, [branchId])
+
+  const cashRange = cashWindow(from, to)
+  useEffect(() => {
+    if (view !== "cash") return
+    bankDepositsApi
+      .cashInHandDaily({ from: cashRange.from, to: cashRange.to, branchId })
+      .then((res) => {
+        setDaily(res)
+        setDailyError(null)
+      })
+      .catch((err) => setDailyError(errorMessage(err)))
+  }, [view, cashRange.from, cashRange.to, branchId])
+
+  function openDeposit(row: BankDeposit) {
+    router.push(`/dashboard/accounts/bank-deposits/${row.bankDepositId}`)
+  }
+
+  function handleShowMore() {
+    setLoadingMore(true)
+    setPaging({ key: pagingKey, page: 1, pageSize: pageSize + rowsPerPage })
+  }
+
+  async function handleExport() {
+    setExporting(true)
+    try {
+      const all: BankDeposit[] = []
+      for (let p = 1; ; p++) {
+        const res = await bankDepositsApi.list({ ...filters, page: p, pageSize: 200 })
+        all.push(...res.items)
+        if (p >= res.pagination.totalPages) break
+      }
+      downloadCsv(`bank-deposits-${from ?? "all"}-to-${to ?? "all"}.csv`, all, [
+        { header: "Doc no", value: (r) => r.docNo },
+        { header: "Business date", value: (r) => r.businessDate },
+        { header: "Deposit date", value: (r) => r.depositDate },
+        { header: "Branch", value: (r) => r.branchName },
+        { header: "From cash account", value: (r) => r.fromCashAccountName },
+        { header: "Bank account", value: (r) => r.toBankAccountName },
+        { header: "Bank", value: (r) => r.toBankName },
+        { header: "Account no", value: (r) => r.toAccountNumber },
+        { header: "Slip no", value: (r) => r.depositSlipNo },
+        { header: "Deposited by", value: (r) => r.depositedBy },
+        { header: "Amount", value: (r) => r.amount.toFixed(2) },
+        { header: "Status", value: (r) => r.status },
+        { header: "GL journal", value: (r) => r.glJournalNo },
+        { header: "Reversal journal", value: (r) => r.glReversalJournalNo },
+      ])
+    } catch (err) {
+      toast.error("Could not export deposits", errorMessage(err))
+    } finally {
+      setExporting(false)
+    }
+  }
+
+  const advancedActive = bankAccountId !== null
+  const hasFilters = status !== "All" || advancedActive || query.length > 0 || dateRange !== "All"
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+        <div>
+          <h1 className="text-2xl font-bold text-foreground">Bank Deposits</h1>
+          <p className="text-base text-muted-foreground">
+            Till cash taken to the bank after the day ends. Only cash is deposited — card, transfer and cheque receipts never sit in the till.
+          </p>
+        </div>
+        <div className="flex flex-col gap-2 sm:flex-row sm:flex-wrap">
+          <Button variant="outline" size="lg" onClick={handleExport} disabled={exporting} className="w-full sm:w-auto">
+            <Download className="size-5" />
+            {exporting ? "Exporting…" : "Export CSV"}
+          </Button>
+          <Link href="/dashboard/accounts/bank-deposits/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
+            <Plus className="size-5" />
+            New Deposit
+          </Link>
+        </div>
+      </div>
+
+      <div className="grid grid-cols-2 gap-3 sm:grid-cols-3">
+        <StatCard label="Deposited (filtered)" value={formatAmount(totalAmount)} icon={Landmark} />
+        {todayCash ? (
+          <>
+            <StatCard label="Cash in hand now" value={formatAmount(todayCash.position.closing)} icon={Wallet} />
+            <StatCard label="Net cash today" value={formatAmount(todayCash.position.netCash)} icon={Coins} />
+          </>
+        ) : (
+          Array.from({ length: 2 }).map((_, i) => <Skeleton key={i} className="h-22.5 rounded-xl" />)
+        )}
+      </div>
+
+      <div className="inline-flex w-fit rounded-lg border bg-muted p-1" role="tablist">
+        {(
+          [
+            ["deposits", "Deposits"],
+            ["cash", "Cash in hand by day"],
+          ] as const
+        ).map(([value, label]) => (
+          <button
+            key={value}
+            type="button"
+            role="tab"
+            aria-selected={view === value}
+            onClick={() => setView(value)}
+            className={cn(
+              "rounded-md px-4 py-1.5 text-sm font-medium transition-colors",
+              view === value ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"
+            )}
+          >
+            {label}
+          </button>
+        ))}
+      </div>
+
+      <div className="rounded-2xl border bg-card shadow-sm">
+        <FilterBar
+          className="border-b px-4 py-4"
+          searchFirst
+          search={searchInput}
+          onSearchChange={setSearchInput}
+          searchPlaceholder="Filter by doc no., slip no. or depositor"
+          advancedActive={advancedActive}
+          onClearAdvanced={() => setBankAccountId(null)}
+          advanced={
+            <Field>
+              <FieldLabel htmlFor="bd-filter-bank">Bank account</FieldLabel>
+              <Select<number | null> value={bankAccountId} onValueChange={(v) => setBankAccountId(v)}>
+                <SelectTrigger id="bd-filter-bank"><SelectValue placeholder="All bank accounts" /></SelectTrigger>
+                <SelectContent>
+                  <SelectItem value={null}>All bank accounts</SelectItem>
+                  {bankAccounts.map((a) => (
+                    <SelectItem key={a.accountId} value={a.accountId}>
+                      {a.accountName}
+                      {a.accountNumber ? ` · ${maskAccountNumber(a.accountNumber)}` : ""}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </Field>
+          }
+        >
+          <div className="flex flex-wrap items-center gap-2">
+            <Select<StatusFilter> value={status} onValueChange={(v) => setStatus(v ?? "All")}>
+              <SelectTrigger className="h-10! w-36 text-sm" aria-label="Status">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {statusOptions.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+              </SelectContent>
+            </Select>
+
+            <Select<DateRange> value={dateRange} onValueChange={(v) => setDateRange(v ?? "Month")}>
+              <SelectTrigger className="h-10! w-40 text-sm" aria-label="Business date range">
+                <CalendarDays className="size-4 text-muted-foreground" />
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {dateRanges.map((r) => <SelectItem key={r.value} value={r.value}>{r.label}</SelectItem>)}
+              </SelectContent>
+            </Select>
+
+            {dateRange === "Custom" && (
+              <DateRangePicker value={customRange} onChange={setCustomRange} placeholder="Pick from – to dates" className="sm:w-72" />
+            )}
+          </div>
+        </FilterBar>
+
+        {view === "cash" ? (
+          <CashByDay daily={daily} error={dailyError} />
+        ) : (
+          <>
+            {error && <div className="mx-4 mt-4 rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+
+            {!error && rows === null && (
+              <div className="flex flex-col gap-3 px-4 py-4">
+                {Array.from({ length: 5 }).map((_, i) => (
+                  <Skeleton key={i} className="h-14 w-full" />
+                ))}
+              </div>
+            )}
+
+            {!error && rows !== null && rows.length === 0 && (
+              <div className="flex flex-col items-center gap-4 px-4 py-20 text-center">
+                <PiggyBank className="size-12 text-muted-foreground" />
+                <p className="text-base text-muted-foreground">{hasFilters ? "No deposits match your filters." : "No deposits yet."}</p>
+              </div>
+            )}
+
+            {!error && rows !== null && rows.length > 0 && (
+              <>
+                {/* Mobile: stacked cards. */}
+                <div className="flex flex-col gap-3 px-4 py-4 md:hidden">
+                  {rows.map((row) => (
+                    <div
+                      key={row.bankDepositId}
+                      role="link"
+                      tabIndex={0}
+                      onClick={() => openDeposit(row)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter") openDeposit(row)
+                      }}
+                      className="flex flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm"
+                    >
+                      <div className="flex items-start justify-between gap-2">
+                        <div className="min-w-0">
+                          <p className="truncate font-semibold text-foreground">{row.docNo}</p>
+                          <p className="truncate text-sm text-muted-foreground">{row.toBankAccountName}</p>
+                          <p className="truncate text-sm text-muted-foreground">{bankLabel(row)}</p>
+                        </div>
+                        <BankDepositStatusBadge status={row.status} />
+                      </div>
+                      <div className="grid grid-cols-2 gap-3 border-t pt-3 text-sm">
+                        <div>
+                          <p className="text-muted-foreground">Business date</p>
+                          <p className="font-medium text-foreground">{formatReportDate(row.businessDate)}</p>
+                        </div>
+                        <div>
+                          <p className="text-muted-foreground">Amount</p>
+                          <p className="font-semibold text-foreground tabular-nums">{formatAmount(row.amount)}</p>
+                        </div>
+                        <div>
+                          <p className="text-muted-foreground">Deposited on</p>
+                          <p className="font-medium text-foreground">{formatReportDate(row.depositDate)}</p>
+                        </div>
+                        <div>
+                          <p className="text-muted-foreground">Slip no.</p>
+                          <p className="font-medium text-foreground">{row.depositSlipNo ?? "—"}</p>
+                        </div>
+                      </div>
+                    </div>
+                  ))}
+
+                  <div className="flex items-center justify-between rounded-xl border bg-muted/40 px-4 py-3 text-sm">
+                    <span className="text-muted-foreground">Total ({pagination?.totalItems ?? rows.length})</span>
+                    <span className="font-semibold tabular-nums text-foreground">{formatAmount(totalAmount)}</span>
+                  </div>
+
+                  {pagination && rows.length < pagination.totalItems && (
+                    <Button type="button" variant="outline" size="lg" className="w-full" onClick={handleShowMore} disabled={loadingMore}>
+                      {loadingMore ? "Loading…" : "Show more"}
+                    </Button>
+                  )}
+                </div>
+
+                {/* Desktop: table. */}
+                <div className="mx-4 my-4 hidden overflow-x-auto rounded-xl border md:block">
+                  <Table className="text-base">
+                    <TableHeader>
+                      <TableRow>
+                        <TableHead className="h-12 px-3 text-sm">Deposit</TableHead>
+                        <TableHead className="h-12 px-3 text-sm">Business date</TableHead>
+                        <TableHead className="h-12 px-3 text-sm">Deposited on</TableHead>
+                        {showBranch && <TableHead className="h-12 px-3 text-sm">Branch</TableHead>}
+                        <TableHead className="h-12 px-3 text-sm">Bank account</TableHead>
+                        <TableHead className="h-12 px-3 text-sm">Slip no.</TableHead>
+                        <TableHead className="h-12 px-3 text-right text-sm">Amount</TableHead>
+                        <TableHead className="h-12 px-3 text-sm">Status</TableHead>
+                        <TableHead className="h-12 px-3 text-sm"><span className="sr-only">Open</span></TableHead>
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                      {rows.map((row) => (
+                        <TableRow key={row.bankDepositId} className="cursor-pointer" onClick={() => openDeposit(row)}>
+                          <TableCell className="px-3 py-3.5 font-medium">
+                            <div className="flex items-center gap-3">
+                              <div className="flex size-8 shrink-0 items-center justify-center rounded-lg bg-primary/10">
+                                <PiggyBank className="size-4 text-primary" />
+                              </div>
+                              <div>
+                                <p>{row.docNo}</p>
+                                {row.depositedBy && <p className="text-xs font-normal text-muted-foreground">By {row.depositedBy}</p>}
+                              </div>
+                            </div>
+                          </TableCell>
+                          <TableCell className="px-3 py-3.5">{formatReportDate(row.businessDate)}</TableCell>
+                          <TableCell className="px-3 py-3.5">{formatReportDate(row.depositDate)}</TableCell>
+                          {showBranch && (
+                            <TableCell className="px-3 py-3.5">
+                              <Badge variant="outline" className="h-5 w-fit justify-center border-transparent bg-primary/10 px-2 text-xs text-primary">
+                                {row.branchName ?? `#${row.branchId}`}
+                              </Badge>
+                            </TableCell>
+                          )}
+                          <TableCell className="px-3 py-3.5">
+                            <p>{row.toBankAccountName}</p>
+                            <p className="text-xs text-muted-foreground">{bankLabel(row)}</p>
+                          </TableCell>
+                          <TableCell className="px-3 py-3.5">{row.depositSlipNo ?? "—"}</TableCell>
+                          <TableCell className={cn("px-3 py-3.5 text-right font-semibold tabular-nums", row.status === "Cancelled" && "text-muted-foreground line-through")}>
+                            {formatAmount(row.amount)}
+                          </TableCell>
+                          <TableCell className="px-3 py-3.5"><BankDepositStatusBadge status={row.status} /></TableCell>
+                          <TableCell className="px-3 py-3.5">
+                            <Button type="button" variant="ghost" size="icon-sm" aria-label={`Open ${row.docNo}`} title="Open">
+                              <FileText className="size-4" />
+                            </Button>
+                          </TableCell>
+                        </TableRow>
+                      ))}
+                    </TableBody>
+                    <TableFooter>
+                      <TableRow>
+                        <TableCell colSpan={showBranch ? 6 : 5} className="px-3 py-3 text-sm text-muted-foreground">
+                          Total of {pagination?.totalItems ?? rows.length} deposit{(pagination?.totalItems ?? rows.length) === 1 ? "" : "s"}
+                          {status === "All" ? " (cancelled ones included)" : ""}
+                        </TableCell>
+                        <TableCell className="px-3 py-3 text-right font-bold tabular-nums">{formatAmount(totalAmount)}</TableCell>
+                        <TableCell colSpan={2} />
+                      </TableRow>
+                    </TableFooter>
+                  </Table>
+                </div>
+
+                {pagination && (
+                  <div className="hidden px-4 pb-4 md:block">
+                    <PaginationFooter pagination={pagination} onPageChange={setPage} pageSizeOptions={PAGE_SIZE_OPTIONS} onPageSizeChange={setRowsPerPage} />
+                  </div>
+                )}
+              </>
+            )}
+          </>
+        )}
+      </div>
+    </div>
+  )
+}
+
+/** Day-wise till cash: Opening · Cash in · Cash out · Deposited · Closing, newest day first. */
+function CashByDay({ daily, error }: { daily: CashInHandDaily | null; error: string | null }) {
+  if (error) return <div className="mx-4 my-4 rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+  if (!daily) {
+    return (
+      <div className="flex flex-col gap-3 px-4 py-4">
+        {Array.from({ length: 5 }).map((_, i) => <Skeleton key={i} className="h-10 w-full" />)}
+      </div>
+    )
+  }
+
+  const days = [...daily.days].reverse()
+  return (
+    <div className="flex flex-col gap-2 px-4 py-4">
+      <p className="text-sm text-muted-foreground">
+        {formatReportDate(daily.from)} – {formatReportDate(daily.to)} (at most {MAX_CASH_DAYS} days)
+        {daily.trackingStartDate ? ` · cash in hand counted from ${formatReportDate(daily.trackingStartDate)}` : ""}
+      </p>
+      <div className="overflow-x-auto rounded-xl border">
+        <Table className="text-base">
+          <TableHeader>
+            <TableRow>
+              <TableHead className="h-11 px-3 text-sm">Date</TableHead>
+              <TableHead className="h-11 px-3 text-right text-sm">Opening</TableHead>
+              <TableHead className="h-11 px-3 text-right text-sm">Cash in</TableHead>
+              <TableHead className="h-11 px-3 text-right text-sm">Cash out</TableHead>
+              <TableHead className="h-11 px-3 text-right text-sm">Deposited</TableHead>
+              <TableHead className="h-11 px-3 text-right text-sm">Cash in hand</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {days.map((d) => (
+              <TableRow key={d.date}>
+                <TableCell className="px-3 py-2.5">{formatReportDate(d.date)}</TableCell>
+                <TableCell className="px-3 py-2.5 text-right tabular-nums">{formatAmount(d.opening, true)}</TableCell>
+                <TableCell className="px-3 py-2.5 text-right tabular-nums">{formatAmount(d.cashIn, true)}</TableCell>
+                <TableCell className="px-3 py-2.5 text-right tabular-nums">{formatAmount(d.cashOut, true)}</TableCell>
+                <TableCell className="px-3 py-2.5 text-right tabular-nums">{formatAmount(d.deposited, true)}</TableCell>
+                <TableCell className={cn("px-3 py-2.5 text-right font-semibold tabular-nums", d.closing > 0 && "text-warning")}>
+                  {formatAmount(d.closing)}
+                </TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </div>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/expense-setup/page.tsx b/Frontend/erp-system/app/dashboard/accounts/expense-setup/page.tsx
new file mode 100644
index 0000000..bbb0877
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/expense-setup/page.tsx
@@ -0,0 +1,263 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { Lock, Pencil, Plus, Tags } from "lucide-react"
+
+import { expenseSetupApi } from "@/lib/api/expenses"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { EntityStatus } from "@/types/common"
+import { ExpenseCategory, ExpenseTitle } from "@/types/expenses"
+
+import { AddTitleDialog } from "@/components/accounts/ExpenseForm"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldDescription, FieldGroup, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Switch } from "@/components/ui/switch"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { toast } from "@/components/ui/toast"
+
+/** What the edit dialog is editing — a category (no GL code) or a title. */
+type Editing = { kind: "category"; row: ExpenseCategory } | { kind: "title"; row: ExpenseTitle } | null
+
+export default function ExpenseSetupPage() {
+  const [categories, setCategories] = useState<ExpenseCategory[] | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [selectedId, setSelectedId] = useState<number | null>(null)
+  const [addTitleOpen, setAddTitleOpen] = useState(false)
+  const [editing, setEditing] = useState<Editing>(null)
+
+  function load() {
+    expenseSetupApi
+      .list(true)
+      .then((rows) => {
+        setCategories(rows)
+        setSelectedId((prev) => prev ?? rows[0]?.expenseCategoryId ?? null)
+      })
+      .catch((err) => setError(errorMessage(err)))
+  }
+
+  useEffect(load, [])
+
+  const selected = categories?.find((c) => c.expenseCategoryId === selectedId) ?? null
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Expense Setup</h1>
+        <p className="text-base text-muted-foreground">
+          The four expense categories are fixed; add your own titles under them. Built-in rows can be deactivated but not renamed.
+        </p>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!error && categories === null && <Skeleton className="h-80 w-full" />}
+
+      {categories && (
+        <div className="grid grid-cols-1 gap-4 lg:grid-cols-[16rem_1fr]">
+          <nav className="flex gap-2 overflow-x-auto lg:flex-col" aria-label="Expense categories">
+            {categories.map((c) => (
+              <button
+                key={c.expenseCategoryId}
+                onClick={() => setSelectedId(c.expenseCategoryId)}
+                className={cn(
+                  "flex shrink-0 items-center justify-between gap-2 rounded-xl border px-4 py-3 text-left text-sm transition-colors",
+                  c.expenseCategoryId === selectedId ? "border-primary bg-primary/5 text-foreground" : "bg-card text-muted-foreground hover:text-foreground",
+                  c.status === "Inactive" && "opacity-60"
+                )}
+              >
+                <span className="font-medium">{c.name}</span>
+                <span className="text-xs tabular-nums">{c.titles.length}</span>
+              </button>
+            ))}
+          </nav>
+
+          {selected && (
+            <div className="rounded-2xl border bg-card shadow-sm">
+              <div className="flex flex-col gap-3 border-b px-4 py-4 sm:flex-row sm:items-center sm:justify-between">
+                <div className="flex flex-wrap items-center gap-2">
+                  <Tags className="size-5 text-primary" />
+                  <h2 className="text-lg font-semibold text-foreground">{selected.name}</h2>
+                  <span className="text-xs text-muted-foreground">{selected.code}</span>
+                  {selected.isSystem && <SystemBadge />}
+                  {selected.status === "Inactive" && <InactiveBadge />}
+                </div>
+                <div className="flex gap-2">
+                  <Button variant="outline" size="sm" onClick={() => setEditing({ kind: "category", row: selected })}>
+                    <Pencil className="size-4" />
+                    Edit category
+                  </Button>
+                  <Button size="sm" onClick={() => setAddTitleOpen(true)}>
+                    <Plus className="size-4" />
+                    Add title
+                  </Button>
+                </div>
+              </div>
+
+              {selected.code === "SALARIES" && (
+                <p className="mx-4 mt-4 rounded-lg border border-warning/30 bg-warning/5 p-3 text-sm text-warning">
+                  Payroll runs in HRM don&apos;t post to the ledger yet. If they start to, record salaries there only, or they will be counted twice.
+                </p>
+              )}
+
+              {selected.titles.length === 0 ? (
+                <p className="px-4 py-10 text-center text-sm text-muted-foreground">No titles yet — add the first one.</p>
+              ) : (
+                <div className="overflow-x-auto">
+                  <Table className="text-base">
+                    <TableHeader>
+                      <TableRow>
+                        <TableHead className="h-11 px-4 text-sm">Title</TableHead>
+                        <TableHead className="h-11 px-4 text-sm">GL expense account</TableHead>
+                        <TableHead className="h-11 px-4 text-sm">Status</TableHead>
+                        <TableHead className="h-11 px-4 text-right text-sm">Actions</TableHead>
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                      {selected.titles.map((t) => (
+                        <TableRow key={t.expenseTitleId} className={cn(t.status === "Inactive" && "opacity-60")}>
+                          <TableCell className="px-4 py-3">
+                            <span className="inline-flex items-center gap-2">
+                              {t.name}
+                              {t.isSystem && <Lock className="size-3.5 text-muted-foreground" aria-label="Built-in" />}
+                            </span>
+                          </TableCell>
+                          <TableCell className="px-4 py-3 tabular-nums">{t.glExpenseAccountCode}</TableCell>
+                          <TableCell className="px-4 py-3">{t.status === "Active" ? "Active" : <InactiveBadge />}</TableCell>
+                          <TableCell className="px-4 py-3 text-right">
+                            <Button variant="ghost" size="sm" onClick={() => setEditing({ kind: "title", row: t })}>
+                              <Pencil className="size-4" />
+                              Edit
+                            </Button>
+                          </TableCell>
+                        </TableRow>
+                      ))}
+                    </TableBody>
+                  </Table>
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+      )}
+
+      {selected && (
+        <AddTitleDialog
+          open={addTitleOpen}
+          onOpenChange={setAddTitleOpen}
+          category={selected}
+          onCreated={(title) =>
+            setCategories((prev) =>
+              prev?.map((c) => (c.expenseCategoryId === title.expenseCategoryId ? { ...c, titles: [...c.titles, title] } : c)) ?? prev
+            )
+          }
+        />
+      )}
+
+      <EditDialog editing={editing} onClose={() => setEditing(null)} onSaved={load} />
+    </div>
+  )
+}
+
+function SystemBadge() {
+  return (
+    <Badge variant="outline" className="h-5 gap-1 border-transparent bg-muted px-2 text-xs text-muted-foreground">
+      <Lock className="size-3" />
+      Built-in
+    </Badge>
+  )
+}
+
+function InactiveBadge() {
+  return (
+    <Badge variant="outline" className="h-5 border-transparent bg-muted px-2 text-xs text-muted-foreground">
+      Inactive
+    </Badge>
+  )
+}
+
+function EditDialog({ editing, onClose, onSaved }: { editing: Editing; onClose: () => void; onSaved: () => void }) {
+  const [name, setName] = useState("")
+  const [glCode, setGlCode] = useState("")
+  const [active, setActive] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [saving, setSaving] = useState(false)
+
+  // Reset whenever a different row is opened — "adjust state while rendering", as in the payment dialogs.
+  const key = editing ? `${editing.kind}-${editing.kind === "category" ? editing.row.expenseCategoryId : editing.row.expenseTitleId}` : null
+  const [resetFor, setResetFor] = useState<string | null>(null)
+  if (key !== resetFor) {
+    setResetFor(key)
+    if (editing) {
+      setName(editing.row.name)
+      setGlCode(editing.kind === "title" ? editing.row.glExpenseAccountCode : "")
+      setActive(editing.row.status === "Active")
+      setError(null)
+    }
+  }
+
+  if (!editing) return null
+  const isSystem = editing.row.isSystem
+
+  async function submit() {
+    if (!editing) return
+    if (!name.trim()) return setError("Enter a name")
+    if (editing.kind === "title" && !glCode.trim()) return setError("Enter the GL expense account code")
+    const status: EntityStatus = active ? "Active" : "Inactive"
+    setSaving(true)
+    try {
+      if (editing.kind === "category") {
+        await expenseSetupApi.updateCategory(editing.row.expenseCategoryId, { name: name.trim(), status })
+      } else {
+        await expenseSetupApi.updateTitle(editing.row.expenseTitleId, { name: name.trim(), glExpenseAccountCode: glCode.trim(), status })
+      }
+      toast.success("Saved", name.trim())
+      onSaved()
+      onClose()
+    } catch (err) {
+      setError(errorMessage(err))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <Dialog open onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>Edit {editing.kind === "category" ? "category" : "title"}</DialogTitle>
+        </DialogHeader>
+        <FieldGroup>
+          <Field>
+            <FieldLabel htmlFor="edit-name" required>Name</FieldLabel>
+            <Input id="edit-name" value={name} maxLength={100} disabled={isSystem} onChange={(e) => setName(e.target.value)} />
+            {isSystem && <FieldDescription>Built-in names can&apos;t be changed.</FieldDescription>}
+          </Field>
+          {editing.kind === "title" && (
+            <Field>
+              <FieldLabel htmlFor="edit-gl" required>GL expense account code</FieldLabel>
+              <Input id="edit-gl" value={glCode} maxLength={20} onChange={(e) => setGlCode(e.target.value)} />
+              <FieldDescription>Used for expenses posted from now on; already-posted expenses keep their account.</FieldDescription>
+            </Field>
+          )}
+          <Field orientation="horizontal">
+            <Switch id="edit-active" checked={active} onCheckedChange={setActive} />
+            <FieldLabel htmlFor="edit-active">Active — offered on new expenses</FieldLabel>
+          </Field>
+          {error && <p className="text-sm text-destructive">{error}</p>}
+        </FieldGroup>
+        <DialogFooter>
+          <Button variant="outline" onClick={onClose} disabled={saving}>
+            Cancel
+          </Button>
+          <Button onClick={submit} disabled={saving}>
+            {saving ? "Saving…" : "Save"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/expenses/[id]/edit/page.tsx b/Frontend/erp-system/app/dashboard/accounts/expenses/[id]/edit/page.tsx
new file mode 100644
index 0000000..a98998d
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/expenses/[id]/edit/page.tsx
@@ -0,0 +1,57 @@
+"use client"
+
+import { use, useEffect, useState } from "react"
+import { useRouter } from "next/navigation"
+
+import { expensesApi } from "@/lib/api/expenses"
+import { errorMessage } from "@/lib/error-map"
+import { Expense } from "@/types/expenses"
+
+import { ExpenseForm } from "@/components/accounts/ExpenseForm"
+import { Skeleton } from "@/components/ui/skeleton"
+
+export default function EditExpensePage({ params }: { params: Promise<{ id: string }> }) {
+  const router = useRouter()
+  const { id } = use(params)
+  const expenseId = Number(id)
+
+  const [loaded, setLoaded] = useState<{ expense: Expense; etag: string | null } | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const error = Number.isFinite(expenseId) ? loadError : `Invalid expense id '${id}'.`
+
+  useEffect(() => {
+    if (!Number.isFinite(expenseId)) return
+    expensesApi
+      .get(expenseId)
+      .then((res) => {
+        if (res.data.status !== "Draft") {
+          // Only drafts are editable — send anything else back to its detail page.
+          router.replace(`/dashboard/accounts/expenses/${expenseId}`)
+          return
+        }
+        setLoaded({ expense: res.data, etag: res.etag })
+      })
+      .catch((err) => setLoadError(errorMessage(err)))
+  }, [expenseId, id, router])
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Edit Expense {loaded?.expense.docNo ?? ""}</h1>
+        <p className="text-base text-muted-foreground">Drafts stay editable until they are posted.</p>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!error && !loaded && <Skeleton className="h-96 w-full" />}
+      {loaded && (
+        <ExpenseForm
+          existing={loaded}
+          cancelHref={`/dashboard/accounts/expenses/${expenseId}`}
+          onSaved={(expense, action) =>
+            router.push(`/dashboard/accounts/expenses/${expense.expenseId}${action === "pay" ? "?pay=1" : ""}`)
+          }
+        />
+      )}
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/expenses/[id]/page.tsx b/Frontend/erp-system/app/dashboard/accounts/expenses/[id]/page.tsx
new file mode 100644
index 0000000..b077bd6
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/expenses/[id]/page.tsx
@@ -0,0 +1,334 @@
+"use client"
+
+import { use, useCallback, useEffect, useState } from "react"
+import Link from "next/link"
+import { useRouter } from "next/navigation"
+import { ArrowLeft, Ban, CheckCircle2, CircleDollarSign, Pencil, Trash2 } from "lucide-react"
+
+import { expensesApi } from "@/lib/api/expenses"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { Expense, expensePaymentMethodLabels } from "@/types/expenses"
+
+import { ExpensePaymentDialog } from "@/components/accounts/ExpensePaymentDialog"
+import { ExpensePaymentStatusBadge, ExpenseStatusBadge, isExpenseOverdue } from "@/components/accounts/expense-badges"
+import { localToday } from "@/components/sales/PaymentLinesEditor"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldLabel } from "@/components/ui/field"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { Textarea } from "@/components/ui/textarea"
+import { toast } from "@/components/ui/toast"
+
+export default function ExpenseDetailPage({ params }: { params: Promise<{ id: string }> }) {
+  const router = useRouter()
+  const { id } = use(params)
+  const expenseId = Number(id)
+
+  const [expense, setExpense] = useState<Expense | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const error = Number.isFinite(expenseId) ? loadError : `Invalid expense id '${id}'.`
+  const [busy, setBusy] = useState<"post" | "delete" | "cancel" | null>(null)
+  const [payOpen, setPayOpen] = useState(false)
+  const [cancelOpen, setCancelOpen] = useState(false)
+  const [deleteOpen, setDeleteOpen] = useState(false)
+  const [cancelReason, setCancelReason] = useState("")
+  const [cancelError, setCancelError] = useState<string | null>(null)
+
+  const load = useCallback(() => {
+    if (!Number.isFinite(expenseId)) return
+    expensesApi
+      .get(expenseId)
+      .then((res) => {
+        setExpense(res.data)
+        if (consumePayFlag() && res.data.status !== "Cancelled" && res.data.balanceAmount > 0) setPayOpen(true)
+      })
+      .catch((err) => setLoadError(errorMessage(err)))
+  }, [expenseId])
+
+  useEffect(load, [load])
+
+  async function handlePost() {
+    if (!expense) return
+    setBusy("post")
+    try {
+      const posted = await expensesApi.post(expense.expenseId)
+      setExpense(posted)
+      toast.success("Expense posted", `Journal ${posted.glJournalNo ?? "—"}`)
+    } catch (err) {
+      toast.error("Could not post expense", errorMessage(err))
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  async function handleDelete() {
+    if (!expense) return
+    setBusy("delete")
+    try {
+      await expensesApi.remove(expense.expenseId)
+      toast.success("Draft deleted", expense.docNo)
+      router.push("/dashboard/accounts/expenses")
+    } catch (err) {
+      toast.error("Could not delete expense", errorMessage(err))
+      setBusy(null)
+    }
+  }
+
+  async function handleCancel() {
+    if (!expense) return
+    if (!cancelReason.trim()) {
+      setCancelError("Enter a reason")
+      return
+    }
+    setBusy("cancel")
+    try {
+      const cancelled = await expensesApi.cancel(expense.expenseId, cancelReason.trim())
+      setExpense(cancelled)
+      setCancelOpen(false)
+      toast.success(
+        "Expense cancelled",
+        cancelled.glReversalJournalNo ? `Reversing journal ${cancelled.glReversalJournalNo}` : cancelled.docNo
+      )
+    } catch (err) {
+      setCancelError(errorMessage(err))
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  if (error) {
+    return (
+      <div className="flex flex-col gap-4">
+        <BackLink />
+        <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+      </div>
+    )
+  }
+  if (!expense) return <Skeleton className="h-96 w-full" />
+
+  const overdue = isExpenseOverdue(expense, localToday())
+  const canPay = expense.status !== "Cancelled" && expense.balanceAmount > 0
+  const canCancel = expense.status !== "Cancelled" && expense.paidAmount === 0
+
+  return (
+    <div className="flex flex-col gap-6">
+      <BackLink />
+
+      <div className="flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between">
+        <div className="flex flex-col gap-2">
+          <div className="flex flex-wrap items-center gap-3">
+            <h1 className="text-2xl font-bold text-foreground">{expense.docNo}</h1>
+            <ExpenseStatusBadge status={expense.status} />
+            {expense.status === "Posted" && <ExpensePaymentStatusBadge status={expense.paymentStatus} />}
+          </div>
+          <p className="text-base text-muted-foreground">
+            {expense.categoryName} · {expense.titleName}
+            {expense.payee ? ` — ${expense.payee}` : ""}
+          </p>
+        </div>
+
+        <div className="flex flex-wrap gap-2">
+          {expense.status === "Draft" && (
+            <>
+              <Link href={`/dashboard/accounts/expenses/${expense.expenseId}/edit`} className={cn(buttonVariants({ variant: "outline" }))}>
+                <Pencil className="size-4" />
+                Edit
+              </Link>
+              <Button variant="outline" onClick={() => setDeleteOpen(true)} disabled={busy !== null}>
+                <Trash2 className="size-4" />
+                Delete
+              </Button>
+              <Button variant="outline" onClick={handlePost} disabled={busy !== null}>
+                <CheckCircle2 className="size-4" />
+                {busy === "post" ? "Posting…" : "Post"}
+              </Button>
+            </>
+          )}
+          {expense.status === "Posted" && canCancel && (
+            <Button
+              variant="outline"
+              onClick={() => {
+                setCancelReason("")
+                setCancelError(null)
+                setCancelOpen(true)
+              }}
+              disabled={busy !== null}
+            >
+              <Ban className="size-4" />
+              Cancel expense
+            </Button>
+          )}
+          {canPay && (
+            <Button onClick={() => setPayOpen(true)} disabled={busy !== null}>
+              <CircleDollarSign className="size-4" />
+              {expense.status === "Draft" ? "Post & Pay" : "Pay"}
+            </Button>
+          )}
+        </div>
+      </div>
+
+      <div className="grid grid-cols-1 gap-3 sm:grid-cols-3">
+        <Amount label="Amount" value={expense.amount} />
+        <Amount label="Paid" value={expense.paidAmount} />
+        <Amount label="Balance" value={expense.balanceAmount} tone={overdue ? "danger" : undefined} hint={overdue ? "Overdue" : undefined} />
+      </div>
+
+      <div className="rounded-2xl border bg-card p-4 shadow-sm sm:p-6">
+        <dl className="grid grid-cols-1 gap-x-6 gap-y-4 text-sm sm:grid-cols-2 lg:grid-cols-3">
+          <Detail label="Bill date" value={formatReportDate(expense.expenseDate)} />
+          <Detail label="Due date" value={expense.dueDate ? formatReportDate(expense.dueDate) : "—"} danger={overdue} />
+          <Detail label="Period covered" value={expense.periodMonth ?? "—"} />
+          <Detail label="Category" value={expense.categoryName} />
+          <Detail label="Title" value={expense.titleName} />
+          <Detail label="Payee" value={expense.payee ?? "—"} />
+          <Detail label="Vendor" value={expense.vendorName ?? "—"} />
+          <Detail label="Bill / account ref" value={expense.billReference ?? "—"} />
+          <Detail label="Created" value={formatReportDate(expense.createdAt)} />
+          {expense.status !== "Draft" && (
+            <>
+              <Detail label="GL expense account" value={expense.glExpenseAccountCode ?? "—"} />
+              <Detail label="Accrual journal" value={expense.glJournalNo ?? "—"} />
+              <Detail label="Posted" value={formatReportDate(expense.glPostedAt)} />
+            </>
+          )}
+          {expense.status === "Cancelled" && (
+            <>
+              <Detail label="Reversal journal" value={expense.glReversalJournalNo ?? "— (cancelled as draft)"} />
+              <Detail label="Cancel reason" value={expense.cancelReason ?? "—"} />
+            </>
+          )}
+          {expense.description && (
+            <div className="sm:col-span-2 lg:col-span-3">
+              <dt className="text-muted-foreground">Description</dt>
+              <dd className="mt-0.5 whitespace-pre-wrap text-foreground">{expense.description}</dd>
+            </div>
+          )}
+        </dl>
+      </div>
+
+      <div className="rounded-2xl border bg-card shadow-sm">
+        <div className="border-b px-4 py-3">
+          <h2 className="text-base font-semibold text-foreground">Payments</h2>
+        </div>
+        {expense.payments.length === 0 ? (
+          <p className="px-4 py-8 text-center text-sm text-muted-foreground">No payments recorded yet.</p>
+        ) : (
+          <div className="overflow-x-auto">
+            <Table className="text-base">
+              <TableHeader>
+                <TableRow>
+                  <TableHead className="h-11 px-4 text-sm">Date</TableHead>
+                  <TableHead className="h-11 px-4 text-sm">Method</TableHead>
+                  <TableHead className="h-11 px-4 text-sm">Account</TableHead>
+                  <TableHead className="h-11 px-4 text-sm">Cheque / ref</TableHead>
+                  <TableHead className="h-11 px-4 text-sm">Journal</TableHead>
+                  <TableHead className="h-11 px-4 text-right text-sm">Amount</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {expense.payments.map((p) => (
+                  <TableRow key={p.expensePaymentId}>
+                    <TableCell className="px-4 py-3">{formatReportDate(p.paymentDate)}</TableCell>
+                    <TableCell className="px-4 py-3">{expensePaymentMethodLabels[p.paymentMethod]}</TableCell>
+                    <TableCell className="px-4 py-3">{p.bankAccountName}</TableCell>
+                    <TableCell className="px-4 py-3">{[p.chequeNo, p.reference].filter(Boolean).join(" · ") || "—"}</TableCell>
+                    <TableCell className="px-4 py-3">{p.glJournalNo ?? "—"}</TableCell>
+                    <TableCell className="px-4 py-3 text-right font-medium tabular-nums">{formatAmount(p.amount)}</TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+        )}
+      </div>
+
+      <ExpensePaymentDialog
+        expense={expense}
+        open={payOpen}
+        onOpenChange={setPayOpen}
+        onDone={(updated) => (updated ? setExpense(updated) : load())}
+      />
+
+      <Dialog open={cancelOpen} onOpenChange={setCancelOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Cancel expense {expense.docNo}</DialogTitle>
+          </DialogHeader>
+          <p className="text-sm text-muted-foreground">
+            A reversing journal entry will be posted to the ledger. This cannot be undone.
+          </p>
+          <Field data-invalid={!!cancelError}>
+            <FieldLabel htmlFor="exp-cancel-reason" required>Reason</FieldLabel>
+            <Textarea id="exp-cancel-reason" value={cancelReason} maxLength={250} rows={3} onChange={(e) => setCancelReason(e.target.value)} />
+            <FieldError errors={[cancelError ? { message: cancelError } : undefined]} />
+          </Field>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setCancelOpen(false)} disabled={busy === "cancel"}>
+              Keep it
+            </Button>
+            <Button variant="destructive" onClick={handleCancel} disabled={busy === "cancel"}>
+              {busy === "cancel" ? "Cancelling…" : "Cancel expense"}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      <Dialog open={deleteOpen} onOpenChange={setDeleteOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Delete draft {expense.docNo}?</DialogTitle>
+          </DialogHeader>
+          <p className="text-sm text-muted-foreground">The draft has not been posted, so nothing reaches the ledger. This cannot be undone.</p>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setDeleteOpen(false)} disabled={busy === "delete"}>
+              Keep it
+            </Button>
+            <Button variant="destructive" onClick={handleDelete} disabled={busy === "delete"}>
+              {busy === "delete" ? "Deleting…" : "Delete draft"}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  )
+}
+
+/** "Save & pay" on the form lands here with ?pay=1 — true once, then the flag is dropped from the URL. */
+function consumePayFlag(): boolean {
+  const url = new URL(window.location.href)
+  if (url.searchParams.get("pay") !== "1") return false
+  url.searchParams.delete("pay")
+  window.history.replaceState(null, "", url.toString())
+  return true
+}
+
+function BackLink() {
+  return (
+    <Link href="/dashboard/accounts/expenses" className="inline-flex w-fit items-center gap-1.5 text-sm font-medium text-muted-foreground hover:text-foreground">
+      <ArrowLeft className="size-4" />
+      Expenses
+    </Link>
+  )
+}
+
+function Amount({ label, value, tone, hint }: { label: string; value: number; tone?: "danger"; hint?: string }) {
+  return (
+    <div className="rounded-xl border bg-card p-4 shadow-sm">
+      <p className="text-sm text-muted-foreground">{label}</p>
+      <p className={cn("text-xl font-bold tabular-nums", tone === "danger" ? "text-destructive" : "text-foreground")}>{formatAmount(value)}</p>
+      {hint && <p className="text-xs font-medium text-destructive">{hint}</p>}
+    </div>
+  )
+}
+
+function Detail({ label, value, danger }: { label: string; value: string; danger?: boolean }) {
+  return (
+    <div>
+      <dt className="text-muted-foreground">{label}</dt>
+      <dd className={cn("mt-0.5 font-medium", danger ? "text-destructive" : "text-foreground")}>{value}</dd>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/expenses/new/page.tsx b/Frontend/erp-system/app/dashboard/accounts/expenses/new/page.tsx
new file mode 100644
index 0000000..58a8350
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/expenses/new/page.tsx
@@ -0,0 +1,27 @@
+"use client"
+
+import { useRouter } from "next/navigation"
+
+import { ExpenseForm } from "@/components/accounts/ExpenseForm"
+
+export default function NewExpensePage() {
+  const router = useRouter()
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">New Expense</h1>
+        <p className="text-base text-muted-foreground">
+          Record a bill — pick its category and title, then save it as a draft, post it, or post and pay it in one step.
+        </p>
+      </div>
+
+      <ExpenseForm
+        cancelHref="/dashboard/accounts/expenses"
+        onSaved={(expense, action) =>
+          router.push(`/dashboard/accounts/expenses/${expense.expenseId}${action === "pay" ? "?pay=1" : ""}`)
+        }
+      />
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/expenses/page.tsx b/Frontend/erp-system/app/dashboard/accounts/expenses/page.tsx
new file mode 100644
index 0000000..3f025bf
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/accounts/expenses/page.tsx
@@ -0,0 +1,637 @@
+"use client"
+
+import { useEffect, useMemo, useState } from "react"
+import Link from "next/link"
+import { useRouter } from "next/navigation"
+import {
+  AlertTriangle,
+  ArrowDown,
+  ArrowUp,
+  ArrowUpDown,
+  CalendarDays,
+  CheckCircle2,
+  CircleDollarSign,
+  Download,
+  FileText,
+  Loader2,
+  Plus,
+  Receipt,
+  Wallet,
+} from "lucide-react"
+
+import { expenseSetupApi, expensesApi } from "@/lib/api/expenses"
+import { branchesHrmApi } from "@/lib/api/hrm-masters"
+import { downloadCsv } from "@/lib/csv-export"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { PaginationMeta } from "@/types/common"
+import { Branch } from "@/types/hrm"
+import {
+  ExpenseCategory,
+  ExpenseListFilterParams,
+  ExpensePaymentStatus,
+  ExpenseStatus,
+  ExpenseSummary,
+  ExpenseSummaryReport,
+} from "@/types/expenses"
+
+import { useAuth } from "@/components/auth/AuthProvider"
+import { ExpensePaymentDialog } from "@/components/accounts/ExpensePaymentDialog"
+import { ExpensePaymentStatusBadge, ExpenseStatusBadge, isExpenseOverdue } from "@/components/accounts/expense-badges"
+import { localToday } from "@/components/sales/PaymentLinesEditor"
+import { Badge } from "@/components/ui/badge"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { DateRangePicker } from "@/components/ui/date-picker"
+import { Field, FieldLabel } from "@/components/ui/field"
+import { FilterBar } from "@/components/ui/filter-bar"
+import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { StatCard } from "@/components/ui/stat-card"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { toast } from "@/components/ui/toast"
+
+type StatusFilter = ExpenseStatus | "All"
+type PaymentFilter = ExpensePaymentStatus | "All" | "Overdue"
+type SortKey = "docNo" | "date" | "title" | "payee" | "due" | "amount" | "balance"
+type SortOrder = "asc" | "desc"
+type DateRange = "Month" | "Today" | "7d" | "30d" | "All" | "Custom"
+type CustomRange = { from: Date | undefined; to?: Date | undefined }
+
+const statusOptions: { value: StatusFilter; label: string }[] = [
+  { value: "All", label: "All statuses" },
+  { value: "Draft", label: "Draft" },
+  { value: "Posted", label: "Posted" },
+  { value: "Cancelled", label: "Cancelled" },
+]
+const paymentOptions: { value: PaymentFilter; label: string }[] = [
+  { value: "All", label: "Any payment status" },
+  { value: "Unpaid", label: "Unpaid" },
+  { value: "PartiallyPaid", label: "Partially paid" },
+  { value: "Paid", label: "Paid" },
+  { value: "Overdue", label: "Overdue" },
+]
+const dateRanges: { value: DateRange; label: string }[] = [
+  { value: "Month", label: "This month" },
+  { value: "Today", label: "Today" },
+  { value: "7d", label: "7 days" },
+  { value: "30d", label: "30 days" },
+  { value: "All", label: "All time" },
+  { value: "Custom", label: "Custom range" },
+]
+
+const PAGE_SIZE_OPTIONS = [5, 10, 15, 20]
+// "All time" still needs a lower bound for the period summary (the API defaults to this month).
+const ALL_TIME_FROM = "2000-01-01"
+
+/** Local yyyy-MM-dd — the API's DateOnly `from`/`to` format. */
+function toIsoDate(d: Date) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
+}
+
+/** Inclusive bounds ending today, as on the Sales list. A custom range with only a start covers that day. */
+function dateRangeBounds(range: DateRange, custom: CustomRange | undefined): { from?: string; to?: string } {
+  const today = new Date()
+  if (range === "Custom") {
+    if (!custom?.from) return {}
+    return { from: toIsoDate(custom.from), to: toIsoDate(custom.to ?? custom.from) }
+  }
+  if (range === "All") return {}
+  if (range === "Month") return { from: toIsoDate(new Date(today.getFullYear(), today.getMonth(), 1)), to: toIsoDate(today) }
+  const days = range === "Today" ? 1 : range === "7d" ? 7 : 30
+  const from = new Date(today)
+  from.setDate(today.getDate() - (days - 1))
+  return { from: toIsoDate(from), to: toIsoDate(today) }
+}
+
+/** Same clickable sort header as the Sales and Items tables. */
+function SortableHeader({ label, active, order, onClick, alignRight }: { label: string; active: boolean; order: SortOrder; onClick: () => void; alignRight?: boolean }) {
+  return (
+    <button type="button" className={cn("flex items-center gap-1 hover:text-foreground", alignRight && "ml-auto")} onClick={onClick}>
+      {label}
+      {active ? (
+        order === "asc" ? <ArrowUp className="size-3.5" /> : <ArrowDown className="size-3.5" />
+      ) : (
+        <ArrowUpDown className="size-3.5 text-muted-foreground/50" />
+      )}
+    </button>
+  )
+}
+
+export default function ExpensesPage() {
+  const router = useRouter()
+  const { isAdmin, activeBranchId, branchingEnabled } = useAuth()
+  const today = localToday()
+
+  const [rows, setRows] = useState<ExpenseSummary[] | null>(null)
+  const [pagination, setPagination] = useState<PaginationMeta | null>(null)
+  const [summary, setSummary] = useState<ExpenseSummaryReport | null>(null)
+  const [categories, setCategories] = useState<ExpenseCategory[]>([])
+  const [branches, setBranches] = useState<Branch[]>([])
+  const [error, setError] = useState<string | null>(null)
+  const [loadingMore, setLoadingMore] = useState(false)
+
+  const [status, setStatus] = useState<StatusFilter>("All")
+  const [paymentFilter, setPaymentFilter] = useState<PaymentFilter>("All")
+  const [categoryId, setCategoryId] = useState<number | null>(null)
+  const [titleId, setTitleId] = useState<number | null>(null)
+  const [dateRange, setDateRange] = useState<DateRange>("Month")
+  const [customRange, setCustomRange] = useState<CustomRange | undefined>(undefined)
+  const { from, to } = dateRangeBounds(dateRange, customRange)
+  const [searchInput, setSearchInput] = useState("")
+  const [query, setQuery] = useState("")
+  const [rowsPerPage, setRowsPerPage] = useState(PAGE_SIZE_OPTIONS[1])
+  const [reloadKey, setReloadKey] = useState(0)
+
+  const [postingId, setPostingId] = useState<number | null>(null)
+  const [payExpense, setPayExpense] = useState<ExpenseSummary | null>(null)
+  const [payOpen, setPayOpen] = useState(false)
+  const [exporting, setExporting] = useState(false)
+  const [sortKey, setSortKey] = useState<SortKey | null>(null)
+  const [sortOrder, setSortOrder] = useState<SortOrder>("asc")
+
+  useEffect(() => {
+    expenseSetupApi.list(true).then(setCategories).catch(() => setCategories([]))
+  }, [])
+
+  useEffect(() => {
+    if (isAdmin && branchingEnabled) branchesHrmApi.list({ pageSize: 200, status: "Active" }).then((r) => setBranches(r.items)).catch(() => setBranches([]))
+  }, [isAdmin, branchingEnabled])
+
+  useEffect(() => {
+    const timeout = setTimeout(() => setQuery(searchInput.trim()), 300)
+    return () => clearTimeout(timeout)
+  }, [searchInput])
+
+  const filters: ExpenseListFilterParams = useMemo(
+    () => ({
+      q: query || undefined,
+      status: status === "All" ? undefined : status,
+      paymentStatus: paymentFilter === "All" || paymentFilter === "Overdue" ? undefined : paymentFilter,
+      overdueOnly: paymentFilter === "Overdue" ? true : undefined,
+      categoryId: categoryId ?? undefined,
+      titleId: titleId ?? undefined,
+      from,
+      to,
+    }),
+    [query, status, paymentFilter, categoryId, titleId, from, to]
+  )
+
+  // Page and fetched size belong to one filter combination: any filter change (or a new rows-per-page)
+  // drops back to page 1. pageSize grows on mobile "Show more", like the Sales list.
+  const pagingKey = `${JSON.stringify(filters)}|${rowsPerPage}`
+  const [paging, setPaging] = useState({ key: "", page: 1, pageSize: rowsPerPage })
+  const { page, pageSize } = paging.key === pagingKey ? paging : { page: 1, pageSize: rowsPerPage }
+  const setPage = (p: number) => setPaging({ key: pagingKey, page: p, pageSize })
+
+  useEffect(() => {
+    expensesApi
+      .list({ ...filters, page, pageSize })
+      .then((res) => {
+        setError(null)
+        setRows(res.items)
+        setPagination(res.pagination)
+      })
+      .catch((err) => setError(errorMessage(err)))
+      .finally(() => setLoadingMore(false))
+  }, [filters, page, pageSize, reloadKey, activeBranchId])
+
+  useEffect(() => {
+    expensesApi
+      .summary({ from: from ?? ALL_TIME_FROM, to: to ?? today })
+      .then(setSummary)
+      .catch(() => setSummary(null))
+  }, [from, to, today, reloadKey, activeBranchId])
+
+  const titleOptions = useMemo(
+    () => (categoryId ? categories.find((c) => c.expenseCategoryId === categoryId)?.titles ?? [] : categories.flatMap((c) => c.titles)),
+    [categories, categoryId]
+  )
+
+  // Admins bypass branch scoping server-side — the header's branch switcher filters client-side,
+  // as on Purchase Invoices (docs/BRANCH_ISOLATION_PLAN.md §Frontend impact).
+  const visibleRows = useMemo(
+    () => rows?.filter((row) => !(isAdmin && branchingEnabled && activeBranchId) || row.branchId === activeBranchId) ?? [],
+    [rows, isAdmin, branchingEnabled, activeBranchId]
+  )
+
+  // Desktop sorting over the loaded page, client-side; null keeps the server's order (newest first).
+  function toggleSort(key: SortKey) {
+    if (key === sortKey) setSortOrder((o) => (o === "asc" ? "desc" : "asc"))
+    else {
+      setSortKey(key)
+      setSortOrder("asc")
+    }
+  }
+  const sortedRows = useMemo(() => {
+    if (!sortKey) return visibleRows
+    const value = (r: ExpenseSummary): string | number => {
+      switch (sortKey) {
+        case "docNo": return r.docNo
+        case "date": return r.expenseDate
+        case "title": return `${r.categoryName} ${r.titleName}`
+        case "payee": return r.payee ?? ""
+        case "due": return r.dueDate ?? ""
+        case "amount": return r.amount
+        case "balance": return r.balanceAmount
+      }
+    }
+    return [...visibleRows].sort((a, b) => {
+      const va = value(a), vb = value(b)
+      const cmp = typeof va === "number" && typeof vb === "number" ? va - vb : String(va).localeCompare(String(vb))
+      return sortOrder === "asc" ? cmp : -cmp
+    })
+  }, [visibleRows, sortKey, sortOrder])
+
+  function branchName(branchId: number) {
+    return branches.find((b) => b.branchId === branchId)?.name ?? `#${branchId}`
+  }
+
+  function openExpense(row: ExpenseSummary) {
+    router.push(`/dashboard/accounts/expenses/${row.expenseId}`)
+  }
+
+  function openPay(row: ExpenseSummary) {
+    setPayExpense(row)
+    setPayOpen(true)
+  }
+
+  async function handlePost(row: ExpenseSummary) {
+    setPostingId(row.expenseId)
+    try {
+      const posted = await expensesApi.post(row.expenseId)
+      toast.success("Expense posted", `${posted.docNo} — journal ${posted.glJournalNo ?? "—"}`)
+      setReloadKey((k) => k + 1)
+    } catch (err) {
+      toast.error("Could not post expense", errorMessage(err))
+    } finally {
+      setPostingId(null)
+    }
+  }
+
+  function handleShowMore() {
+    setLoadingMore(true)
+    setPaging({ key: pagingKey, page: 1, pageSize: pageSize + rowsPerPage })
+  }
+
+  async function handleExport() {
+    setExporting(true)
+    try {
+      const all: ExpenseSummary[] = []
+      for (let p = 1; ; p++) {
+        const res = await expensesApi.list({ ...filters, page: p, pageSize: 200 })
+        all.push(...res.items)
+        if (p >= res.pagination.totalPages) break
+      }
+      downloadCsv(`expenses-${from ?? "all"}-to-${to ?? "all"}.csv`, all, [
+        { header: "Doc no", value: (r) => r.docNo },
+        { header: "Date", value: (r) => r.expenseDate },
+        { header: "Due date", value: (r) => r.dueDate },
+        { header: "Category", value: (r) => r.categoryName },
+        { header: "Title", value: (r) => r.titleName },
+        { header: "Payee", value: (r) => r.payee },
+        { header: "Bill ref", value: (r) => r.billReference },
+        { header: "Period", value: (r) => r.periodMonth },
+        { header: "Amount", value: (r) => r.amount.toFixed(2) },
+        { header: "Paid", value: (r) => r.paidAmount.toFixed(2) },
+        { header: "Balance", value: (r) => r.balanceAmount.toFixed(2) },
+        { header: "Status", value: (r) => r.status },
+        { header: "Payment status", value: (r) => (r.status === "Posted" ? r.paymentStatus : "") },
+        { header: "GL journal", value: (r) => r.glJournalNo },
+      ])
+    } catch (err) {
+      toast.error("Could not export expenses", errorMessage(err))
+    } finally {
+      setExporting(false)
+    }
+  }
+
+  const advancedActive = paymentFilter !== "All" || categoryId !== null || titleId !== null
+  const hasFilters = status !== "All" || advancedActive || query.length > 0 || dateRange !== "All"
+  const showBranch = isAdmin && branchingEnabled
+
+  /** Icon-only row actions, same as the Sales list: open, post (drafts), pay / post & pay. */
+  function rowActions(row: ExpenseSummary, variant: "ghost" | "outline", size: "icon-sm" | "icon") {
+    const posting = postingId === row.expenseId
+    return (
+      <>
+        <Button type="button" variant={variant} size={size} onClick={() => openExpense(row)} aria-label={`Open ${row.docNo}`} title="Open">
+          <FileText className="size-4" />
+        </Button>
+        {row.status === "Draft" && (
+          <Button
+            type="button"
+            variant={variant}
+            size={size}
+            disabled={posting}
+            onClick={() => handlePost(row)}
+            aria-label={`Post ${row.docNo}`}
+            title={posting ? "Posting…" : "Post"}
+          >
+            {posting ? <Loader2 className="size-4 animate-spin" /> : <CheckCircle2 className="size-4" />}
+          </Button>
+        )}
+        {row.status !== "Cancelled" && row.balanceAmount > 0 && (
+          <Button
+            type="button"
+            variant={variant}
+            size={size}
+            onClick={() => openPay(row)}
+            aria-label={`${row.status === "Draft" ? "Post and pay" : "Pay"} ${row.docNo}`}
+            title={row.status === "Draft" ? "Post & Pay" : "Pay"}
+          >
+            <CircleDollarSign className="size-4" />
+          </Button>
+        )}
+      </>
+    )
+  }
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+        <div>
+          <h1 className="text-2xl font-bold text-foreground">Expenses</h1>
+          <p className="text-base text-muted-foreground">Utility bills, rent, salaries and other business expenses, with payment tracking.</p>
+        </div>
+        <div className="flex flex-col gap-2 sm:flex-row sm:flex-wrap">
+          <Button variant="outline" size="lg" onClick={handleExport} disabled={exporting} className="w-full sm:w-auto">
+            <Download className="size-5" />
+            {exporting ? "Exporting…" : "Export CSV"}
+          </Button>
+          <Link href="/dashboard/accounts/expenses/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
+            <Plus className="size-5" />
+            New Expense
+          </Link>
+        </div>
+      </div>
+
+      {/* Amounts are passed as strings so StatCard shows full 2dp values rather than its compact "1.2K" form. */}
+      <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
+        {summary ? (
+          <>
+            <StatCard label="Posted in period" value={formatAmount(summary.totalAmount)} icon={Receipt} />
+            <StatCard label="Unpaid in period" value={formatAmount(summary.unpaidAmount)} icon={Wallet} />
+            <StatCard label="Outstanding (all time)" value={formatAmount(summary.outstandingAmount)} icon={CircleDollarSign} />
+            <StatCard label={`Overdue (${summary.overdueCount})`} value={formatAmount(summary.overdueAmount)} icon={AlertTriangle} />
+          </>
+        ) : (
+          Array.from({ length: 4 }).map((_, i) => <Skeleton key={i} className="h-22.5 rounded-xl" />)
+        )}
+      </div>
+
+      <div className="rounded-2xl border bg-card shadow-sm">
+        <FilterBar
+          className="border-b px-4 py-4"
+          searchFirst
+          search={searchInput}
+          onSearchChange={setSearchInput}
+          searchPlaceholder="Filter by doc no., payee or bill ref"
+          advancedActive={advancedActive}
+          onClearAdvanced={() => {
+            setPaymentFilter("All")
+            setCategoryId(null)
+            setTitleId(null)
+          }}
+          advanced={
+            <>
+              <Field>
+                <FieldLabel htmlFor="exp-filter-payment">Payment status</FieldLabel>
+                <Select<PaymentFilter> value={paymentFilter} onValueChange={(v) => setPaymentFilter(v ?? "All")}>
+                  <SelectTrigger id="exp-filter-payment"><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {paymentOptions.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+                  </SelectContent>
+                </Select>
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="exp-filter-category">Category</FieldLabel>
+                <Select<number | null>
+                  value={categoryId}
+                  onValueChange={(v) => {
+                    setCategoryId(v)
+                    setTitleId(null)
+                  }}
+                >
+                  <SelectTrigger id="exp-filter-category"><SelectValue placeholder="All categories" /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value={null}>All categories</SelectItem>
+                    {categories.map((c) => <SelectItem key={c.expenseCategoryId} value={c.expenseCategoryId}>{c.name}</SelectItem>)}
+                  </SelectContent>
+                </Select>
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="exp-filter-title">Title</FieldLabel>
+                <Select<number | null> value={titleId} onValueChange={(v) => setTitleId(v)}>
+                  <SelectTrigger id="exp-filter-title"><SelectValue placeholder="All titles" /></SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value={null}>All titles</SelectItem>
+                    {titleOptions.map((t) => <SelectItem key={t.expenseTitleId} value={t.expenseTitleId}>{t.name}</SelectItem>)}
+                  </SelectContent>
+                </Select>
+              </Field>
+            </>
+          }
+        >
+          <div className="flex flex-wrap items-center gap-2">
+            <Select<StatusFilter> value={status} onValueChange={(v) => setStatus(v ?? "All")}>
+              <SelectTrigger className="h-10! w-36 text-sm" aria-label="Status">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {statusOptions.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+              </SelectContent>
+            </Select>
+
+            <Select<DateRange> value={dateRange} onValueChange={(v) => setDateRange(v ?? "Month")}>
+              <SelectTrigger className="h-10! w-40 text-sm" aria-label="Date range">
+                <CalendarDays className="size-4 text-muted-foreground" />
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {dateRanges.map((r) => <SelectItem key={r.value} value={r.value}>{r.label}</SelectItem>)}
+              </SelectContent>
+            </Select>
+
+            {dateRange === "Custom" && (
+              <DateRangePicker value={customRange} onChange={setCustomRange} placeholder="Pick from – to dates" className="sm:w-72" />
+            )}
+          </div>
+        </FilterBar>
+
+        {error && <div className="mx-4 mt-4 rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+
+        {!error && rows === null && (
+          <div className="flex flex-col gap-3 px-4 py-4">
+            {Array.from({ length: 5 }).map((_, i) => (
+              <Skeleton key={i} className="h-14 w-full" />
+            ))}
+          </div>
+        )}
+
+        {!error && rows !== null && visibleRows.length === 0 && (
+          <div className="flex flex-col items-center gap-4 px-4 py-20 text-center">
+            <Receipt className="size-12 text-muted-foreground" />
+            <p className="text-base text-muted-foreground">{hasFilters ? "No expenses match your filters." : "No expenses yet."}</p>
+          </div>
+        )}
+
+        {!error && rows !== null && visibleRows.length > 0 && (
+          <>
+            {/* Mobile: stacked cards. */}
+            <div className="flex flex-col gap-3 px-4 py-4 md:hidden">
+              {visibleRows.map((row) => (
+                <div
+                  key={row.expenseId}
+                  role="link"
+                  tabIndex={0}
+                  onClick={(e) => {
+                    if ((e.target as HTMLElement).closest("[data-no-row-nav]")) return
+                    openExpense(row)
+                  }}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") openExpense(row)
+                  }}
+                  className="flex flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm"
+                >
+                  <div className="flex items-start justify-between gap-2">
+                    <div className="min-w-0">
+                      <p className="truncate font-semibold text-foreground">{row.docNo}</p>
+                      <p className="truncate text-sm text-muted-foreground">
+                        {row.categoryName} · {row.titleName}
+                      </p>
+                      {row.payee && <p className="truncate text-sm text-muted-foreground">{row.payee}</p>}
+                    </div>
+                    <div className="flex shrink-0 flex-col items-end gap-1">
+                      <ExpenseStatusBadge status={row.status} />
+                      {row.status === "Posted" && <ExpensePaymentStatusBadge status={row.paymentStatus} />}
+                    </div>
+                  </div>
+
+                  <div className="grid grid-cols-2 gap-3 border-t pt-3 text-sm">
+                    <div>
+                      <p className="text-muted-foreground">Date / Due</p>
+                      <p className="font-medium text-foreground">
+                        {formatReportDate(row.expenseDate)} /{" "}
+                        <span className={cn(isExpenseOverdue(row, today) && "text-destructive")}>
+                          {row.dueDate ? formatReportDate(row.dueDate) : "—"}
+                        </span>
+                      </p>
+                    </div>
+                    <div>
+                      <p className="text-muted-foreground">Amount</p>
+                      <p className="font-semibold text-foreground tabular-nums">{formatAmount(row.amount)}</p>
+                    </div>
+                    <div>
+                      <p className="text-muted-foreground">Paid</p>
+                      <p className="font-medium text-foreground tabular-nums">{formatAmount(row.paidAmount)}</p>
+                    </div>
+                    <div>
+                      <p className="text-muted-foreground">Balance</p>
+                      <p className="font-medium text-foreground tabular-nums">{formatAmount(row.balanceAmount)}</p>
+                    </div>
+                  </div>
+
+                  <div className="flex items-center justify-end gap-2 border-t pt-3" data-no-row-nav>
+                    {rowActions(row, "outline", "icon")}
+                  </div>
+                </div>
+              ))}
+
+              {pagination && rows.length < pagination.totalItems && (
+                <Button type="button" variant="outline" size="lg" className="w-full" onClick={handleShowMore} disabled={loadingMore}>
+                  {loadingMore ? "Loading…" : "Show more"}
+                </Button>
+              )}
+            </div>
+
+            {/* Desktop: table. */}
+            <div className="mx-4 my-4 hidden overflow-x-auto rounded-xl border md:block">
+              <Table className="text-base">
+                <TableHeader>
+                  <TableRow>
+                    <TableHead className="h-12 px-3 text-sm"><SortableHeader label="Expense" active={sortKey === "docNo"} order={sortOrder} onClick={() => toggleSort("docNo")} /></TableHead>
+                    <TableHead className="h-12 px-3 text-sm"><SortableHeader label="Category / Title" active={sortKey === "title"} order={sortOrder} onClick={() => toggleSort("title")} /></TableHead>
+                    <TableHead className="h-12 px-3 text-sm"><SortableHeader label="Payee" active={sortKey === "payee"} order={sortOrder} onClick={() => toggleSort("payee")} /></TableHead>
+                    <TableHead className="h-12 px-3 text-sm"><SortableHeader label="Date" active={sortKey === "date"} order={sortOrder} onClick={() => toggleSort("date")} /></TableHead>
+                    <TableHead className="h-12 px-3 text-sm"><SortableHeader label="Due" active={sortKey === "due"} order={sortOrder} onClick={() => toggleSort("due")} /></TableHead>
+                    <TableHead className="h-12 px-3 text-right text-sm"><SortableHeader label="Amount" active={sortKey === "amount"} order={sortOrder} onClick={() => toggleSort("amount")} alignRight /></TableHead>
+                    <TableHead className="h-12 px-3 text-right text-sm"><SortableHeader label="Balance" active={sortKey === "balance"} order={sortOrder} onClick={() => toggleSort("balance")} alignRight /></TableHead>
+                    {showBranch && <TableHead className="h-12 px-3 text-sm">Branch</TableHead>}
+                    <TableHead className="h-12 px-3 text-sm">Status</TableHead>
+                    <TableHead className="h-12 px-3 text-sm">Actions</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {sortedRows.map((row) => (
+                    <TableRow
+                      key={row.expenseId}
+                      className="cursor-pointer"
+                      onClick={(e) => {
+                        if ((e.target as HTMLElement).closest("[data-no-row-nav]")) return
+                        openExpense(row)
+                      }}
+                    >
+                      <TableCell className="px-3 py-3.5 font-medium">
+                        <div className="flex items-center gap-3">
+                          <div className="flex size-8 shrink-0 items-center justify-center rounded-lg bg-primary/10">
+                            <Receipt className="size-4 text-primary" />
+                          </div>
+                          <div>
+                            <Link href={`/dashboard/accounts/expenses/${row.expenseId}`} className="hover:underline" data-no-row-nav>
+                              {row.docNo}
+                            </Link>
+                            {row.billReference && <p className="text-xs font-normal text-muted-foreground">Ref {row.billReference}</p>}
+                          </div>
+                        </div>
+                      </TableCell>
+                      <TableCell className="px-3 py-3.5">
+                        <p>{row.titleName}</p>
+                        <p className="text-xs text-muted-foreground">
+                          {row.categoryName}
+                          {row.periodMonth ? ` · ${row.periodMonth}` : ""}
+                        </p>
+                      </TableCell>
+                      <TableCell className="px-3 py-3.5">{row.payee ?? "—"}</TableCell>
+                      <TableCell className="px-3 py-3.5">{formatReportDate(row.expenseDate)}</TableCell>
+                      <TableCell className={cn("px-3 py-3.5", isExpenseOverdue(row, today) && "font-semibold text-destructive")}>
+                        {row.dueDate ? formatReportDate(row.dueDate) : "—"}
+                      </TableCell>
+                      <TableCell className="px-3 py-3.5 text-right font-semibold tabular-nums">{formatAmount(row.amount)}</TableCell>
+                      <TableCell className="px-3 py-3.5 text-right tabular-nums">{formatAmount(row.balanceAmount)}</TableCell>
+                      {showBranch && (
+                        <TableCell className="px-3 py-3.5">
+                          <Badge variant="outline" className="h-5 w-fit justify-center border-transparent bg-primary/10 px-2 text-xs text-primary">
+                            {branchName(row.branchId)}
+                          </Badge>
+                        </TableCell>
+                      )}
+                      <TableCell className="px-3 py-3.5">
+                        <div className="flex flex-col items-start gap-1">
+                          <ExpenseStatusBadge status={row.status} />
+                          {row.status === "Posted" && <ExpensePaymentStatusBadge status={row.paymentStatus} />}
+                        </div>
+                      </TableCell>
+                      <TableCell className="px-3 py-3.5" data-no-row-nav>
+                        <div className="flex items-center gap-1">{rowActions(row, "ghost", "icon-sm")}</div>
+                      </TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+              </Table>
+            </div>
+
+            {pagination && (
+              <div className="hidden px-4 pb-4 md:block">
+                <PaginationFooter pagination={pagination} onPageChange={setPage} pageSizeOptions={PAGE_SIZE_OPTIONS} onPageSizeChange={setRowsPerPage} />
+              </div>
+            )}
+          </>
+        )}
+      </div>
+
+      <ExpensePaymentDialog expense={payExpense} open={payOpen} onOpenChange={setPayOpen} onDone={() => setReloadKey((k) => k + 1)} />
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/accounts/page.tsx b/Frontend/erp-system/app/dashboard/accounts/page.tsx
index 34e7de5..34f53a0 100644
--- a/Frontend/erp-system/app/dashboard/accounts/page.tsx
+++ b/Frontend/erp-system/app/dashboard/accounts/page.tsx
@@ -1,5 +1,5 @@
 import Link from "next/link"
-import { BookText, Inbox, Wallet, type LucideIcon } from "lucide-react"
+import { BookText, Inbox, PiggyBank, Receipt, Tags, Wallet, type LucideIcon } from "lucide-react"
 
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
 
@@ -22,6 +22,24 @@ const areas: { title: string; description: string; href: string; icon: LucideIco
     href: "/dashboard/accounts/received-cheques",
     icon: Inbox,
   },
+  {
+    title: "Expenses",
+    description: "Utility bills, rent, salaries and other expenses — post to the ledger and track what is paid.",
+    href: "/dashboard/accounts/expenses",
+    icon: Receipt,
+  },
+  {
+    title: "Expense Setup",
+    description: "Expense categories and titles, and the GL account each title posts to.",
+    href: "/dashboard/accounts/expense-setup",
+    icon: Tags,
+  },
+  {
+    title: "Bank Deposits",
+    description: "Till cash taken to the bank after the day ends — see the cash in hand, deposit it, and track what is left.",
+    href: "/dashboard/accounts/bank-deposits",
+    icon: PiggyBank,
+  },
 ]
 
 export default function AccountsHubPage() {
@@ -30,7 +48,7 @@ export default function AccountsHubPage() {
       <div>
         <h1 className="text-2xl font-bold text-foreground">Accounts</h1>
         <p className="text-base text-muted-foreground">
-          Cash/Bank accounts and cheque management, from the General Ledger service.
+          Cash/Bank accounts, cheque management and business expenses, posted to the General Ledger service.
         </p>
       </div>
 
diff --git a/Frontend/erp-system/app/dashboard/approvals/page.tsx b/Frontend/erp-system/app/dashboard/approvals/page.tsx
new file mode 100644
index 0000000..5461966
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/approvals/page.tsx
@@ -0,0 +1,197 @@
+"use client"
+
+import { useCallback, useEffect, useState } from "react"
+import Link from "next/link"
+import { ClipboardCheck, PackageMinus, Tag } from "lucide-react"
+
+import { approvalsApi, priceAdjustmentsApi } from "@/lib/api/approvals"
+import { stockAdjustmentsApi } from "@/lib/api/stock-adjustments"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { PendingApproval, PendingApprovals } from "@/types/approvals"
+
+import { Badge } from "@/components/ui/badge"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldLabel } from "@/components/ui/field"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Textarea } from "@/components/ui/textarea"
+import { toast } from "@/components/ui/toast"
+
+function hrefFor(p: PendingApproval) {
+  return p.docType === "ADJ" ? `/dashboard/stock/adjustments/${p.docId}` : `/dashboard/products/price-adjustments/${p.docId}`
+}
+
+/** How long a request has waited — "3 h", "2 days". */
+function age(iso: string) {
+  const hours = Math.floor((Date.now() - new Date(iso).getTime()) / 3_600_000)
+  if (hours < 1) return "just now"
+  if (hours < 24) return `${hours} h`
+  const days = Math.floor(hours / 24)
+  return `${days} day${days === 1 ? "" : "s"}`
+}
+
+/**
+ * The Approvals inbox (docs/DUAL_APPROVAL_PLAN.md §10): pending stock and price adjustments the
+ * current user can approve — actionable first, oldest first — plus their own requests waiting on others.
+ */
+export default function ApprovalsInboxPage() {
+  const [data, setData] = useState<PendingApprovals | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [busyKey, setBusyKey] = useState<string | null>(null)
+  const [rejecting, setRejecting] = useState<PendingApproval | null>(null)
+  const [reason, setReason] = useState("")
+  const [reasonError, setReasonError] = useState<string | null>(null)
+
+  const load = useCallback(() => {
+    approvalsApi.pending().then((d) => { setData(d); setError(null) }).catch((err) => setError(errorMessage(err)))
+  }, [])
+
+  useEffect(load, [load])
+
+  async function approve(p: PendingApproval) {
+    setBusyKey(`${p.docType}-${p.docId}`)
+    try {
+      if (p.docType === "ADJ") {
+        const next = await stockAdjustmentsApi.approve(p.docId)
+        toast.success(next.status === "Posted" ? "Approved and posted" : "Approved", next.status === "Posted" ? `${next.docNo} — stock updated.` : `${next.docNo} now needs a second approval.`)
+      } else {
+        const next = await priceAdjustmentsApi.approve(p.docId)
+        toast.success(next.status === "Approved" ? "Approved — prices applied" : "Approved", next.status === "Approved" ? `${next.docNo} is in effect.` : `${next.docNo} now needs a second approval.`)
+      }
+      load()
+    } catch (err) {
+      toast.error(`Could not approve ${p.docNo}`, errorMessage(err))
+    } finally {
+      setBusyKey(null)
+    }
+  }
+
+  async function reject() {
+    if (!rejecting) return
+    if (!reason.trim()) {
+      setReasonError("Give a reason")
+      return
+    }
+    setBusyKey(`${rejecting.docType}-${rejecting.docId}`)
+    try {
+      if (rejecting.docType === "ADJ") await stockAdjustmentsApi.reject(rejecting.docId, reason.trim())
+      else await priceAdjustmentsApi.reject(rejecting.docId, reason.trim())
+      toast.success("Rejected", rejecting.docNo)
+      setRejecting(null)
+      setReason("")
+      load()
+    } catch (err) {
+      setReasonError(errorMessage(err))
+    } finally {
+      setBusyKey(null)
+    }
+  }
+
+  const actionable = data?.items.filter((i) => i.canApprove) ?? []
+  const waiting = data?.items.filter((i) => !i.canApprove) ?? []
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Approvals</h1>
+        <p className="text-base text-muted-foreground">
+          Stock and price adjustments waiting for approval. Nothing takes effect until it is fully approved — by people other than the requester, and two different people when two approvals are needed.
+        </p>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!error && data === null && <Skeleton className="h-64 w-full" />}
+
+      {data && (
+        <>
+          <Section title={`Waiting for you (${actionable.length})`} empty="Nothing needs your approval right now.">
+            {actionable.map((p) => (
+              <Row key={`${p.docType}-${p.docId}`} item={p}>
+                <Button variant="outline" size="sm" onClick={() => { setRejecting(p); setReason(""); setReasonError(null) }} disabled={busyKey !== null}>
+                  Reject
+                </Button>
+                <Button size="sm" onClick={() => approve(p)} disabled={busyKey !== null}>
+                  {busyKey === `${p.docType}-${p.docId}` ? "Approving…" : p.level >= p.requiredApprovals ? "Approve & apply" : "Approve"}
+                </Button>
+              </Row>
+            ))}
+          </Section>
+
+          {waiting.length > 0 && (
+            <Section title={`Waiting for others (${waiting.length})`} empty="">
+              {waiting.map((p) => (
+                <Row key={`${p.docType}-${p.docId}`} item={p} note={p.whyNot} />
+              ))}
+            </Section>
+          )}
+        </>
+      )}
+
+      <Dialog open={rejecting !== null} onOpenChange={(open) => !open && setRejecting(null)}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Reject {rejecting?.docNo}</DialogTitle>
+            <DialogDescription>Nothing will be applied. The requester is told your reason.</DialogDescription>
+          </DialogHeader>
+          <Field data-invalid={!!reasonError}>
+            <FieldLabel htmlFor="inbox-reject-reason" required>Reason</FieldLabel>
+            <Textarea id="inbox-reject-reason" rows={3} maxLength={250} value={reason} onChange={(e) => { setReason(e.target.value); setReasonError(null) }} />
+            <FieldError errors={[reasonError ? { message: reasonError } : undefined]} />
+          </Field>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setRejecting(null)} disabled={busyKey !== null}>Keep it</Button>
+            <Button variant="destructive" onClick={reject} disabled={busyKey !== null}>Reject</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  )
+}
+
+function Section({ title, empty, children }: { title: string; empty: string; children: React.ReactNode }) {
+  const hasItems = Array.isArray(children) ? children.length > 0 : !!children
+  return (
+    <div className="flex flex-col gap-3">
+      <h2 className="text-base font-semibold text-foreground">{title}</h2>
+      {hasItems ? (
+        <div className="flex flex-col gap-2">{children}</div>
+      ) : (
+        <div className="flex flex-col items-center gap-3 rounded-xl border border-dashed py-12 text-center">
+          <ClipboardCheck className="size-10 text-muted-foreground" />
+          <p className="text-sm text-muted-foreground">{empty}</p>
+        </div>
+      )}
+    </div>
+  )
+}
+
+function Row({ item, note, children }: { item: PendingApproval; note?: string | null; children?: React.ReactNode }) {
+  const Icon = item.docType === "ADJ" ? PackageMinus : Tag
+  return (
+    <div className="flex flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm sm:flex-row sm:items-center sm:justify-between">
+      <div className="flex min-w-0 items-start gap-3">
+        <div className="flex size-9 shrink-0 items-center justify-center rounded-lg bg-primary/10">
+          <Icon className="size-4.5 text-primary" />
+        </div>
+        <div className="min-w-0">
+          <div className="flex flex-wrap items-center gap-2">
+            <Link href={hrefFor(item)} className="font-semibold text-foreground hover:underline">{item.docNo}</Link>
+            <Badge variant="outline" className={cn("border-transparent text-xs", item.level >= 2 ? "bg-primary/10 text-primary" : "bg-warning/10 text-warning")}>
+              {item.requiredApprovals === 2 ? `Approval ${item.level} of 2` : "Needs 1 approval"}
+            </Badge>
+          </div>
+          <p className="truncate text-sm text-muted-foreground">{item.summary}</p>
+          <p className="text-xs text-muted-foreground">
+            Requested by {item.requestedByName ?? `#${item.requestedBy}`} · waiting {age(item.requestedAt)}
+            {note ? ` · ${note}` : ""}
+          </p>
+        </div>
+      </div>
+      <div className="flex shrink-0 items-center gap-2">
+        <Link href={hrefFor(item)} className={cn(buttonVariants({ variant: "ghost", size: "sm" }))}>Open</Link>
+        {children}
+      </div>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/customers/page.tsx b/Frontend/erp-system/app/dashboard/customers/page.tsx
index 235ea61..9bea575 100644
--- a/Frontend/erp-system/app/dashboard/customers/page.tsx
+++ b/Frontend/erp-system/app/dashboard/customers/page.tsx
@@ -8,6 +8,7 @@ import { Eye, Pencil, Plus, Search, Trash2, Users } from "lucide-react"
 import { customersApi } from "@/lib/api/customers"
 import { branchesHrmApi } from "@/lib/api/hrm-masters"
 import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate } from "@/lib/format"
 import { cn } from "@/lib/utils"
 import { generateCustomerCode } from "@/lib/customer-code"
 import { EntityStatus, PaginationMeta } from "@/types/common"
@@ -33,6 +34,7 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { Skeleton } from "@/components/ui/skeleton"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { toast } from "@/components/ui/toast"
+import { EditCustomerDialog } from "@/components/customers/EditCustomerDialog"
 
 type StatusFilter = EntityStatus | "All"
 type TypeFilter = CustomerType | "All"
@@ -42,6 +44,9 @@ const PAGE_SIZE_OPTIONS = [5, 10, 15, 20]
 // re-fetches from page 1, so previously loaded cards stay put and more append below.
 const MOBILE_PAGE_SIZE_STEP = 10
 
+/** Unpaid balance across the customer's Posted invoices (0 against an older backend). */
+const outstanding = (c: Customer) => c.outstandingAmount ?? 0
+
 export default function CustomersPage() {
   const router = useRouter()
   const { isAdmin, branchId: myBranchId, activeBranchId, branchingEnabled } = useAuth()
@@ -63,6 +68,10 @@ export default function CustomersPage() {
   const [newCustomerType, setNewCustomerType] = useState<CustomerType>("B2C")
   const [phone, setPhone] = useState("")
   const [email, setEmail] = useState("")
+  const [addressLine1, setAddressLine1] = useState("")
+  const [addressLine2, setAddressLine2] = useState("")
+  const [city, setCity] = useState("")
+  const [country, setCountry] = useState("")
   const [creditLimit, setCreditLimit] = useState("")
   const [creditDays, setCreditDays] = useState("")
   const [errors, setErrors] = useState<Record<string, string>>({})
@@ -72,6 +81,8 @@ export default function CustomersPage() {
   // customer's own code (mirrors the vendor create dialog).
   const [allCustomerCodes, setAllCustomerCodes] = useState<string[]>([])
   const [actionPendingId, setActionPendingId] = useState<number | null>(null)
+  // The customer whose edit popup is open.
+  const [editingId, setEditingId] = useState<number | null>(null)
   const [showMoreLoading, setShowMoreLoading] = useState(false)
 
   const generatedCode = name.trim() ? generateCustomerCode(name, allCustomerCodes) : ""
@@ -135,6 +146,10 @@ export default function CustomersPage() {
     setNewCustomerType("B2C")
     setPhone("")
     setEmail("")
+    setAddressLine1("")
+    setAddressLine2("")
+    setCity("")
+    setCountry("")
     setCreditLimit("")
     setCreditDays("")
     setBranchFilterId(null)
@@ -156,6 +171,10 @@ export default function CustomersPage() {
         name,
         phone: phone || null,
         email: email || null,
+        addressLine1: addressLine1 || null,
+        addressLine2: addressLine2 || null,
+        city: city || null,
+        country: country || null,
         creditLimit: Number(creditLimit) || 0,
         creditDays: Number(creditDays) || 0,
         branchId: effectiveBranchId ?? 0,
@@ -187,6 +206,17 @@ export default function CustomersPage() {
     }
   }
 
+  /**
+   * Row click → profile page. React bubbles events out of portals along the component tree,
+   * so a click on the delete confirmation (portaled to <body>) still reaches the row; only
+   * navigate for events whose DOM target really is inside the row and not an action cell.
+   */
+  function openRow(e: React.MouseEvent | React.KeyboardEvent, customerId: number) {
+    const target = e.target as HTMLElement
+    if (!e.currentTarget.contains(target) || target.closest("[data-no-row-nav]")) return
+    router.push(`/dashboard/customers/${customerId}`)
+  }
+
   const hasFilters = query.length > 0 || status !== "All" || customerType !== "All"
 
   return (
@@ -213,7 +243,7 @@ export default function CustomersPage() {
             </DialogHeader>
             <FieldGroup>
               <Field data-invalid={!!errors.name}>
-                <FieldLabel htmlFor="c-name">Name</FieldLabel>
+                <FieldLabel htmlFor="c-name" required>Name</FieldLabel>
                 <Input id="c-name" value={name} onChange={(e) => setName(e.target.value)} placeholder="Nimal Perera" aria-invalid={!!errors.name} />
                 <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
               </Field>
@@ -243,6 +273,24 @@ export default function CustomersPage() {
                   <Input id="c-email" type="email" value={email} onChange={(e) => setEmail(e.target.value)} placeholder="customer@example.com" />
                 </Field>
               </div>
+              <Field>
+                <FieldLabel htmlFor="c-addr1">Address line 1 (optional)</FieldLabel>
+                <Input id="c-addr1" value={addressLine1} onChange={(e) => setAddressLine1(e.target.value)} placeholder="No. 12, Galle Road" />
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="c-addr2">Address line 2 (optional)</FieldLabel>
+                <Input id="c-addr2" value={addressLine2} onChange={(e) => setAddressLine2(e.target.value)} placeholder="Wellawatte" />
+              </Field>
+              <div className="grid grid-cols-2 gap-3">
+                <Field>
+                  <FieldLabel htmlFor="c-city">City (optional)</FieldLabel>
+                  <Input id="c-city" value={city} onChange={(e) => setCity(e.target.value)} placeholder="Colombo" />
+                </Field>
+                <Field>
+                  <FieldLabel htmlFor="c-country">Country (optional)</FieldLabel>
+                  <Input id="c-country" value={country} onChange={(e) => setCountry(e.target.value)} placeholder="Sri Lanka" />
+                </Field>
+              </div>
               <div className="grid grid-cols-2 gap-3">
                 <Field>
                   <FieldLabel htmlFor="c-credit-limit">Credit limit (LKR)</FieldLabel>
@@ -255,7 +303,7 @@ export default function CustomersPage() {
               </div>
               {showBranchPicker && (
                 <Field data-invalid={!!errors.branch}>
-                  <FieldLabel htmlFor="c-branch">Branch</FieldLabel>
+                  <FieldLabel htmlFor="c-branch" required>Branch</FieldLabel>
                   <Select<number | null> value={branchFilterId} onValueChange={(v) => setBranchFilterId(v)}>
                     <SelectTrigger id="c-branch" className="w-full" aria-invalid={!!errors.branch}>
                       <SelectValue placeholder="Select branch" />
@@ -357,12 +405,9 @@ export default function CustomersPage() {
                 key={c.customerId}
                 role="link"
                 tabIndex={0}
-                onClick={(e) => {
-                  if ((e.target as HTMLElement).closest("[data-no-row-nav]")) return
-                  router.push(`/dashboard/customers/${c.customerId}`)
-                }}
+                onClick={(e) => openRow(e, c.customerId)}
                 onKeyDown={(e) => {
-                  if (e.key === "Enter") router.push(`/dashboard/customers/${c.customerId}`)
+                  if (e.key === "Enter") openRow(e, c.customerId)
                 }}
                 className="flex flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm"
               >
@@ -391,21 +436,36 @@ export default function CustomersPage() {
                     <p className="text-muted-foreground">Phone</p>
                     <p className="font-medium text-foreground">{c.phone ?? "—"}</p>
                   </div>
-                  <div className="col-span-2">
+                  <div>
                     <p className="text-muted-foreground">Credit limit</p>
                     <p className="font-medium text-foreground">LKR {c.creditLimit.toLocaleString(undefined, { maximumFractionDigits: 2 })}</p>
                   </div>
+                  <div>
+                    <p className="text-muted-foreground">Last paid</p>
+                    <p className="font-medium text-foreground">{c.lastPaymentDate ? formatReportDate(c.lastPaymentDate) : "—"}</p>
+                  </div>
+                  <div>
+                    <p className="text-muted-foreground">Remaining payment</p>
+                    <p className={cn("font-medium tabular-nums", outstanding(c) > 0 ? "text-foreground" : "text-muted-foreground")}>
+                      {outstanding(c) > 0 ? `LKR ${formatAmount(outstanding(c))}` : "—"}
+                    </p>
+                  </div>
+                  <div>
+                    <p className="text-muted-foreground">Unpaid invoices</p>
+                    <p className="font-medium text-foreground">{c.outstandingInvoiceCount ?? 0}</p>
+                  </div>
                 </div>
 
                 <div className="flex items-center justify-end gap-1 border-t pt-3" data-no-row-nav>
-                  <Link
-                    href={`/dashboard/customers/${c.customerId}`}
-                    className={cn(buttonVariants({ variant: "ghost", size: "icon-sm" }))}
+                  <Button
+                    variant="ghost"
+                    size="icon-sm"
                     aria-label={`Edit ${c.customerCode}`}
                     title="Edit"
+                    onClick={() => setEditingId(c.customerId)}
                   >
                     <Pencil className="size-4" />
-                  </Link>
+                  </Button>
 
                   <AlertDialog>
                     <AlertDialogTrigger
@@ -451,6 +511,9 @@ export default function CustomersPage() {
                     <TableHead className="w-28">Type</TableHead>
                     <TableHead className="w-36">Phone</TableHead>
                     <TableHead className="w-36">Credit limit</TableHead>
+                    <TableHead className="w-32">Last paid</TableHead>
+                    <TableHead className="w-36 text-right">Remaining payment</TableHead>
+                    <TableHead className="w-28 text-right">Unpaid invoices</TableHead>
                     <TableHead className="w-28">Status</TableHead>
                     <TableHead className="w-24 text-center">Actions</TableHead>
                   </TableRow>
@@ -460,10 +523,7 @@ export default function CustomersPage() {
                     <TableRow
                       key={c.customerId}
                       className="align-top cursor-pointer hover:bg-muted/20"
-                      onClick={(e) => {
-                        if ((e.target as HTMLElement).closest("[data-no-row-nav]")) return
-                        router.push(`/dashboard/customers/${c.customerId}`)
-                      }}
+                      onClick={(e) => openRow(e, c.customerId)}
                     >
                       <TableCell>
                         <Link href={`/dashboard/customers/${c.customerId}`} className="font-semibold text-foreground hover:underline">
@@ -476,6 +536,19 @@ export default function CustomersPage() {
                       </TableCell>
                       <TableCell className="text-sm text-muted-foreground">{c.phone ?? "—"}</TableCell>
                       <TableCell className="text-sm text-muted-foreground">LKR {c.creditLimit.toLocaleString(undefined, { maximumFractionDigits: 2 })}</TableCell>
+                      <TableCell className="text-sm text-muted-foreground">{c.lastPaymentDate ? formatReportDate(c.lastPaymentDate) : "—"}</TableCell>
+                      <TableCell className={cn("text-right text-sm tabular-nums", outstanding(c) > 0 ? "font-semibold text-foreground" : "text-muted-foreground")}>
+                        {outstanding(c) > 0 ? `LKR ${formatAmount(outstanding(c))}` : "—"}
+                      </TableCell>
+                      <TableCell className="text-right text-sm tabular-nums">
+                        {(c.outstandingInvoiceCount ?? 0) > 0 ? (
+                          <Badge variant="outline" className="h-5 border-transparent bg-warning/10 px-2 text-xs text-warning">
+                            {c.outstandingInvoiceCount}
+                          </Badge>
+                        ) : (
+                          <span className="text-muted-foreground">—</span>
+                        )}
+                      </TableCell>
                       <TableCell>
                         <Badge
                           variant="outline"
@@ -497,14 +570,15 @@ export default function CustomersPage() {
                           >
                             <Eye className="size-4" />
                           </Link>
-                          <Link
-                            href={`/dashboard/customers/${c.customerId}`}
-                            className={cn(buttonVariants({ variant: "ghost", size: "icon-sm" }))}
+                          <Button
+                            variant="ghost"
+                            size="icon-sm"
                             aria-label={`Edit ${c.customerCode}`}
                             title="Edit"
+                            onClick={() => setEditingId(c.customerId)}
                           >
                             <Pencil className="size-4" />
-                          </Link>
+                          </Button>
 
                           <AlertDialog>
                             <AlertDialogTrigger
@@ -549,6 +623,21 @@ export default function CustomersPage() {
           )}
         </>
       )}
+
+      {editingId !== null && (
+        <EditCustomerDialog
+          key={editingId}
+          customerId={editingId}
+          onClose={() => setEditingId(null)}
+          onSaved={(saved) => {
+            // The code is editable here — swap it so later creates de-dupe against the new one.
+            const oldCode = customers?.find((c) => c.customerId === saved.customerId)?.customerCode
+            setAllCustomerCodes((codes) => [...codes.filter((c) => c !== oldCode), saved.customerCode])
+            setEditingId(null)
+            load()
+          }}
+        />
+      )}
     </div>
   )
 }
diff --git a/Frontend/erp-system/app/dashboard/page.tsx b/Frontend/erp-system/app/dashboard/page.tsx
index 9e22166..f00c9e9 100644
--- a/Frontend/erp-system/app/dashboard/page.tsx
+++ b/Frontend/erp-system/app/dashboard/page.tsx
@@ -24,6 +24,7 @@ import { DashboardStats } from "@/types/dashboard"
 import { LedgerEntry } from "@/types/stock"
 import { Warehouse } from "@/types/master-data"
 import { useAuth } from "@/components/auth/AuthProvider"
+import { useIsMobile } from "@/hooks/use-mobile"
 import { StatCard } from "@/components/ui/stat-card"
 import { Skeleton } from "@/components/ui/skeleton"
 import { Badge } from "@/components/ui/badge"
@@ -33,6 +34,8 @@ import BarChart from "@/components/ui/bar-chart"
 import LineChart from "@/components/ui/line-chart"
 
 const TREND_DAYS = 14
+/** Fewest bar slots the valuation chart's axis spans, so a couple of bars sit at the start. */
+const CHART_MIN_SLOTS = 5
 
 function isoDate(d: Date) {
   return d.toISOString().slice(0, 10)
@@ -114,6 +117,13 @@ export default function DashboardPage() {
     }
   }, [trend])
 
+  // Same fixed-axis padding as the product page's chart: with fewer than CHART_MIN_SLOTS
+  // warehouses, Chart.js would center the bars across the full width. Trailing blank slots keep
+  // the bars at the start. Skipped on mobile, where the bars should stretch to fill the card.
+  const isMobile = useIsMobile()
+  const valuationRows = stats?.stockValuationByWarehouse ?? []
+  const valuationPad = isMobile ? 0 : Math.max(0, CHART_MIN_SLOTS - valuationRows.length)
+
   const loaded = stats && movements && trend && warehouses
 
   return (
@@ -172,16 +182,18 @@ export default function DashboardPage() {
             (stats.stockValuationByWarehouse ?? []).length > 0 ? (
               <div className="h-64 sm:h-72">
                 <BarChart
-                  labels={stats.stockValuationByWarehouse.map(
-                    (w) => warehousesById.get(w.warehouseId)?.code ?? `#${w.warehouseId}`
-                  )}
+                  labels={[
+                    ...valuationRows.map((w) => warehousesById.get(w.warehouseId)?.code ?? `#${w.warehouseId}`),
+                    ...Array<string>(valuationPad).fill(""),
+                  ]}
                   datasets={[
                     {
                       label: "Stock Value (LKR)",
-                      data: stats.stockValuationByWarehouse.map((w) => w.total),
+                      data: [...valuationRows.map((w) => w.total), ...Array<null>(valuationPad).fill(null)],
                       backgroundColor: "#E11D48",
                     },
                   ]}
+                  barPercentage={0.6}
                 />
               </div>
             ) : (
diff --git a/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/[id]/page.tsx b/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/[id]/page.tsx
index d834e37..1bc88b2 100644
--- a/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/[id]/page.tsx
@@ -294,7 +294,13 @@ export default function PurchaseInvoiceDetailPage({ params }: { params: Promise<
         </div>
       </section>
 
-      <PurchaseInvoicePaymentDialog invoice={invoice} open={payDialogOpen} onOpenChange={setPayDialogOpen} onPaid={handlePaid} />
+      <PurchaseInvoicePaymentDialog
+        invoice={invoice}
+        open={payDialogOpen}
+        onOpenChange={setPayDialogOpen}
+        onPaid={handlePaid}
+        onFullyPaid={() => router.push("/dashboard/receiving/grn")}
+      />
     </div>
   )
 }
diff --git a/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/page.tsx b/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/page.tsx
index b4c4e91..1998a65 100644
--- a/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/page.tsx
+++ b/Frontend/erp-system/app/dashboard/procurement/purchase-invoices/page.tsx
@@ -433,7 +433,13 @@ export default function PurchaseInvoicesPage() {
         )}
       </div>
 
-      <PurchaseInvoicePaymentDialog invoice={payDialogInvoice} open={payDialogOpen} onOpenChange={setPayDialogOpen} onPaid={handlePaid} />
+      <PurchaseInvoicePaymentDialog
+        invoice={payDialogInvoice}
+        open={payDialogOpen}
+        onOpenChange={setPayDialogOpen}
+        onPaid={handlePaid}
+        onFullyPaid={() => router.push("/dashboard/receiving/grn")}
+      />
     </div>
   )
 }
diff --git a/Frontend/erp-system/app/dashboard/procurement/purchase-returns/new/page.tsx b/Frontend/erp-system/app/dashboard/procurement/purchase-returns/new/page.tsx
index 22ee546..8de035d 100644
--- a/Frontend/erp-system/app/dashboard/procurement/purchase-returns/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/procurement/purchase-returns/new/page.tsx
@@ -9,6 +9,8 @@ import { purchaseReturnsApi } from "@/lib/api/purchase-returns"
 import { grnsApi } from "@/lib/api/grns"
 import { reasonCodesApi } from "@/lib/api/reason-codes"
 import { itemsApi } from "@/lib/api/items"
+import { vendorsApi } from "@/lib/api/vendors"
+import { warehousesApi } from "@/lib/api/warehouses"
 import { errorMessage } from "@/lib/error-map"
 import { validateReturnLine } from "@/lib/validations/procurement"
 import { cn } from "@/lib/utils"
@@ -16,6 +18,7 @@ import { CreatePurchaseReturnLineInput } from "@/types/procurement"
 import { Grn, GrnLine } from "@/types/grn"
 import { ItemListItem } from "@/types/master-data"
 import { ReasonCode } from "@/types/stock"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 
 import { Button, buttonVariants } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
@@ -23,14 +26,22 @@ import { Label } from "@/components/ui/label"
 import { Checkbox } from "@/components/ui/checkbox"
 import { FieldError } from "@/components/ui/field"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Combobox } from "@/components/ui/combobox"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { Skeleton } from "@/components/ui/skeleton"
 import { toast } from "@/components/ui/toast"
 import { HoldStatusBadge } from "@/components/receiving/status-badges"
 
+// The stock checkbox (16px, faint border) and qty box are easy to miss on this form, so both are
+// enlarged and given a solid border here.
+const LINE_CHECKBOX = "size-5 shrink-0 border-2 border-muted-foreground/60"
+const RETURN_QTY_INPUT = "h-11 border-2 border-muted-foreground/40 bg-background text-base font-medium md:text-base"
+
 interface LineState {
   selected: boolean
   qty: string
+  /** Serial line: the received serials going back to the vendor (qty follows the count). */
+  serialIds?: number[]
 }
 
 function NewPurchaseReturnContent() {
@@ -42,6 +53,8 @@ function NewPurchaseReturnContent() {
   const [grns, setGrns] = useState<Grn[] | null>(null)
   const [items, setItems] = useState<ItemListItem[]>([])
   const [reasonCodes, setReasonCodes] = useState<ReasonCode[]>([])
+  const [vendorNames, setVendorNames] = useState<Map<number, string>>(new Map())
+  const [warehouseNames, setWarehouseNames] = useState<Map<number, string>>(new Map())
   const [loadError, setLoadError] = useState<string | null>(null)
 
   const [grnId, setGrnId] = useState<number | null>(presetGrnId)
@@ -52,6 +65,7 @@ function NewPurchaseReturnContent() {
   const [headerError, setHeaderError] = useState<string | null>(null)
   const [submitError, setSubmitError] = useState<string | null>(null)
   const [submitting, setSubmitting] = useState(false)
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   useEffect(() => {
     Promise.all([grnsApi.list({ pageSize: 200 }), itemsApi.list({ pageSize: 200 }), reasonCodesApi.list("Return")])
@@ -62,8 +76,18 @@ function NewPurchaseReturnContent() {
         setReasonCodes(rc.items)
       })
       .catch((err) => setLoadError(errorMessage(err)))
+
+    // Names only make the GRN picker searchable by vendor/warehouse — if these fail the
+    // labels fall back to "#id", so they don't block the form.
+    vendorsApi.list({ pageSize: 200 }).then((r) => setVendorNames(new Map(r.items.map((v) => [v.vendorId, v.name])))).catch(() => {})
+    warehousesApi.list({ pageSize: 200 }).then((r) => setWarehouseNames(new Map(r.items.map((w) => [w.warehouseId, w.name])))).catch(() => {})
   }, [])
 
+  const grnOptions = (grns ?? []).map((g) => ({
+    value: g.grnId,
+    label: `${g.docNo} — ${vendorNames.get(g.vendorId) ?? `Vendor #${g.vendorId}`}, ${warehouseNames.get(g.warehouseId) ?? `Warehouse #${g.warehouseId}`}`,
+  }))
+
   const selectedGrn = grns?.find((g) => g.grnId === grnId) ?? null
 
   useEffect(() => {
@@ -87,14 +111,45 @@ function NewPurchaseReturnContent() {
   }
 
   function toggleLine(line: GrnLine) {
-    setLineState((prev) => ({
-      ...prev,
-      [line.grnLineId]: { selected: !prev[line.grnLineId]?.selected, qty: prev[line.grnLineId]?.qty || String(line.qty) },
-    }))
+    setLineState((prev) => {
+      const selected = !prev[line.grnLineId]?.selected
+      // Ticking pre-fills the full received qty; unticking clears it, so a qty is only ever
+      // shown on lines that will actually be returned.
+      return { ...prev, [line.grnLineId]: { selected, qty: selected ? prev[line.grnLineId]?.qty || String(line.qty) : "" } }
+    })
   }
 
+  // Typing a quantity ticks the line (and clearing it / entering 0 unticks it), so the qty box
+  // can stay editable instead of sitting greyed-out until the checkbox is found and ticked.
   function setQty(grnLineId: number, qty: string) {
-    setLineState((prev) => ({ ...prev, [grnLineId]: { ...prev[grnLineId], qty } }))
+    setLineState((prev) => ({ ...prev, [grnLineId]: { ...prev[grnLineId], qty, selected: Number(qty) > 0 } }))
+  }
+
+  function toggleSerial(grnLineId: number, serialId: number) {
+    setLineState((prev) => {
+      const current = prev[grnLineId]?.serialIds ?? []
+      const next = current.includes(serialId) ? current.filter((id) => id !== serialId) : [...current, serialId]
+      return { ...prev, [grnLineId]: { selected: next.length > 0, qty: next.length > 0 ? String(next.length) : "", serialIds: next } }
+    })
+  }
+
+  /** A serial line lists its received serials to tick — the server refuses any no longer in stock. */
+  function renderSerials(line: GrnLine) {
+    // Serial numbers switched off in Product Configuration: the line goes back as plain stock.
+    if (serialNumbersEnabled === false) return null
+    const serials = (line.serials ?? []).filter((s) => s.serialId !== null)
+    if (serials.length === 0) return null
+    const picked = lineState[line.grnLineId]?.serialIds ?? []
+    return (
+      <div className="mt-2 flex flex-wrap gap-x-4 gap-y-1">
+        {serials.map((s) => (
+          <label key={s.serialId} className="flex items-center gap-1.5 text-sm">
+            <Checkbox checked={picked.includes(s.serialId!)} onCheckedChange={() => toggleSerial(line.grnLineId, s.serialId!)} />
+            <span className="font-mono">{s.serialNo}</span>
+          </label>
+        ))}
+      </div>
+    )
   }
 
   async function handleSubmit() {
@@ -119,6 +174,8 @@ function NewPurchaseReturnContent() {
     const nextErrors: Record<number, Record<string, string>> = {}
     for (const line of selectedLines) {
       const errors = validateReturnLine({ grnLineId: line.grnLineId, qty: lineState[line.grnLineId].qty, maxQty: line.qty })
+      if (serialNumbersEnabled !== false && (line.serials ?? []).some((s) => s.serialId !== null) && (lineState[line.grnLineId].serialIds?.length ?? 0) !== Number(lineState[line.grnLineId].qty))
+        errors.qty = "Tick one serial per unit going back"
       if (Object.keys(errors).length > 0) nextErrors[line.grnLineId] = errors
     }
     setLineErrors(nextErrors)
@@ -131,6 +188,7 @@ function NewPurchaseReturnContent() {
       grnLineId: l.grnLineId,
       itemId: l.itemId,
       qty: Number(lineState[l.grnLineId].qty),
+      serialIds: lineState[l.grnLineId].serialIds?.length ? lineState[l.grnLineId].serialIds : null,
     }))
 
     setSubmitting(true)
@@ -173,18 +231,15 @@ function NewPurchaseReturnContent() {
           <div className="grid grid-cols-1 gap-4 sm:grid-cols-3">
             <div className="flex flex-col gap-2 sm:col-span-2">
               <Label className="text-base">Goods Receipt Note</Label>
-              <Select<number | null> value={grnId} onValueChange={setGrnId} disabled={!!presetGrnId}>
-                <SelectTrigger className="h-12! w-full text-base">
-                  <SelectValue placeholder="Select a confirmed GRN" />
-                </SelectTrigger>
-                <SelectContent>
-                  {(grns ?? []).map((g) => (
-                    <SelectItem key={g.grnId} value={g.grnId} className="text-base">
-                      {g.docNo} — Vendor #{g.vendorId}, Warehouse #{g.warehouseId}
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
+              <Combobox<number>
+                items={grnOptions}
+                value={grnId}
+                onValueChange={setGrnId}
+                disabled={!!presetGrnId}
+                placeholder="Search GRN — number, vendor or warehouse…"
+                emptyText="No confirmed GRNs match."
+                className="h-12 text-base"
+              />
             </div>
             <div className="flex flex-col gap-2">
               <Label className="text-base">Reason</Label>
@@ -218,13 +273,17 @@ function NewPurchaseReturnContent() {
                   const state = lineState[line.grnLineId] ?? { selected: false, qty: "" }
                   const errors = lineErrors[line.grnLineId] ?? {}
                   return (
-                    <div key={line.grnLineId} className="flex flex-col gap-3 rounded-xl border p-4">
-                      <label className="flex items-start gap-3">
-                        <Checkbox checked={state.selected} onCheckedChange={() => toggleLine(line)} className="mt-0.5 shrink-0" />
+                    <div
+                      key={line.grnLineId}
+                      className={cn("flex flex-col gap-3 rounded-xl border p-4", state.selected && "border-primary bg-primary/5")}
+                    >
+                      <label className="flex cursor-pointer items-start gap-3">
+                        <Checkbox checked={state.selected} onCheckedChange={() => toggleLine(line)} className={cn(LINE_CHECKBOX, "mt-0.5")} />
                         <span className="min-w-0 truncate text-base font-medium text-foreground">
                           {item ? `${item.sku} — ${item.name}` : `Item #${line.itemId}`}
                         </span>
                       </label>
+                      {renderSerials(line)}
 
                       <div className="grid grid-cols-2 gap-3 border-t pt-3 text-sm">
                         <div>
@@ -238,17 +297,18 @@ function NewPurchaseReturnContent() {
                       </div>
 
                       <div>
-                        <Label className="text-sm">Return qty</Label>
+                        <Label className="text-sm font-medium text-foreground">Return qty</Label>
                         <Input
                           type="number"
                           min="0"
+                          max={line.qty}
                           step="any"
                           inputMode="decimal"
                           value={state.qty}
-                          disabled={!state.selected}
+                          placeholder={`0 – ${line.qty}`}
                           aria-invalid={!!errors.qty}
                           onChange={(e) => setQty(line.grnLineId, e.target.value)}
-                          className="h-11 text-base"
+                          className={RETURN_QTY_INPUT}
                         />
                         <FieldError errors={[errors.qty ? { message: errors.qty } : undefined]} />
                       </div>
@@ -275,11 +335,19 @@ function NewPurchaseReturnContent() {
                       const state = lineState[line.grnLineId] ?? { selected: false, qty: "" }
                       const errors = lineErrors[line.grnLineId] ?? {}
                       return (
-                        <TableRow key={line.grnLineId}>
+                        <TableRow key={line.grnLineId} className={cn(state.selected && "bg-primary/5 hover:bg-primary/10")}>
                           <TableCell className="px-3 py-3.5">
-                            <Checkbox checked={state.selected} onCheckedChange={() => toggleLine(line)} />
+                            <Checkbox
+                              checked={state.selected}
+                              onCheckedChange={() => toggleLine(line)}
+                              className={LINE_CHECKBOX}
+                              aria-label={`Return ${item?.sku ?? `item #${line.itemId}`}`}
+                            />
+                          </TableCell>
+                          <TableCell className="px-3 py-3.5">
+                            {item ? `${item.sku} — ${item.name}` : `Item #${line.itemId}`}
+                            {renderSerials(line)}
                           </TableCell>
-                          <TableCell className="px-3 py-3.5">{item ? `${item.sku} — ${item.name}` : `Item #${line.itemId}`}</TableCell>
                           <TableCell className="px-3 py-3.5">{line.qty}</TableCell>
                           <TableCell className="px-3 py-3.5">
                             <HoldStatusBadge status={line.holdStatus} />
@@ -288,12 +356,14 @@ function NewPurchaseReturnContent() {
                             <Input
                               type="number"
                               min="0"
+                              max={line.qty}
                               step="any"
                               value={state.qty}
-                              disabled={!state.selected}
+                              placeholder={`0 – ${line.qty}`}
                               aria-invalid={!!errors.qty}
+                              aria-label="Return qty"
                               onChange={(e) => setQty(line.grnLineId, e.target.value)}
-                              className="h-11 text-base"
+                              className={RETURN_QTY_INPUT}
                             />
                             <FieldError errors={[errors.qty ? { message: errors.qty } : undefined]} />
                           </TableCell>
diff --git a/Frontend/erp-system/app/dashboard/procurement/requisitions/new/page.tsx b/Frontend/erp-system/app/dashboard/procurement/requisitions/new/page.tsx
index 292310b..8bf62d9 100644
--- a/Frontend/erp-system/app/dashboard/procurement/requisitions/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/procurement/requisitions/new/page.tsx
@@ -86,10 +86,6 @@ export default function NewRequisitionPage() {
       setSubmitError("Add at least one line.")
       return
     }
-    if (branchingEnabled && !effectiveBranchId) {
-      setSubmitError("Select a branch for this requisition.")
-      return
-    }
 
     const nextLineErrors: Record<string, Record<string, string>> = {}
     for (const line of lines) {
@@ -142,11 +138,11 @@ export default function NewRequisitionPage() {
         <>
           {branchingEnabled && isAdmin && (
             <div className="flex flex-col gap-2 sm:max-w-xs">
-              <Label className="text-base">Branch</Label>
+              <Label className="text-base">Branch (optional)</Label>
               {showBranchPicker ? (
                 <Select<number | null> value={branchFilterId} onValueChange={(v) => setBranchFilterId(v)}>
                   <SelectTrigger className="h-12! w-full text-base">
-                    <SelectValue placeholder="All branches" />
+                    <SelectValue placeholder="Default branch" />
                   </SelectTrigger>
                   <SelectContent>
                     {branches.map((b) => (
diff --git a/Frontend/erp-system/app/dashboard/products/[id]/page.tsx b/Frontend/erp-system/app/dashboard/products/[id]/page.tsx
index fccb967..55f3b6e 100644
--- a/Frontend/erp-system/app/dashboard/products/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/products/[id]/page.tsx
@@ -5,6 +5,7 @@ import { useParams } from "next/navigation"
 import Link from "next/link"
 import { AlertTriangle, ArrowLeft, BadgeDollarSign, Boxes, Package, PackageCheck, Pencil, Save, ShoppingCart, TrendingUp } from "lucide-react"
 
+import { approvalsApi, priceAdjustmentsApi } from "@/lib/api/approvals"
 import { itemsApi } from "@/lib/api/items"
 import { categoriesApi } from "@/lib/api/categories"
 import { productConfig } from "@/lib/api/product-config"
@@ -15,8 +16,9 @@ import { stockApi } from "@/lib/api/stock"
 import { errorMessage, fieldErrors } from "@/lib/error-map"
 import { validateItemForm } from "@/lib/validations/master-data"
 import { cn } from "@/lib/utils"
-import { Item, MeasureUnit, StockNature, TaxRate, TrackingMode, Warranty, WarrantyPeriodMonths } from "@/types/master-data"
+import { Item, ItemReorderSetting, MeasureUnit, StockNature, TaxRate, TrackingMode, Warranty, WarrantyPeriodMonths } from "@/types/master-data"
 import { LedgerEntry } from "@/types/stock"
+import { ItemPriceHistory } from "@/types/approvals"
 
 /** Entry units. Only ml/g are stored — the server normalises L and Kg ×1000 on write. */
 const CONTENT_UNITS: MeasureUnit[] = ["Ml", "L", "G", "Kg"]
@@ -39,6 +41,27 @@ import BarChart from "@/components/ui/bar-chart"
 import { ItemImagesPanel } from "@/components/products/ItemImagesPanel"
 import { ItemReorderPanel } from "@/components/products/ItemReorderPanel"
 
+/**
+ * The Edit dialog's simple low-stock alert, read back from the item's reorder rules: one level and
+ * reorder qty, watching one warehouse (a single rule) or every warehouse (several rules).
+ * `uniform` is false when the rules differ per warehouse — those are edited in Reorder settings.
+ */
+function alertFromRules(rules: ItemReorderSetting[]) {
+  if (rules.length === 0) return { lowStockAt: "", reorderQty: "", warehouseId: null as number | null, uniform: true }
+  const first = rules[0]
+  const uniform = rules.every((r) => r.reorderPoint === first.reorderPoint && r.reorderQty === first.reorderQty)
+  return {
+    lowStockAt: String(first.reorderPoint),
+    reorderQty: String(first.reorderQty),
+    warehouseId: rules.length === 1 ? first.warehouseId : null,
+    uniform,
+  }
+}
+
+function fmtPrice(v: number | null) {
+  return v === null ? "—" : `LKR ${v.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
+}
+
 function docLink(sourceDocType: string, sourceDocId: number): string | null {
   if (sourceDocType === "GRN") return `/dashboard/receiving/grn/${sourceDocId}`
   if (sourceDocType === "SI") return `/dashboard/sales/invoices/${sourceDocId}`
@@ -108,9 +131,14 @@ export default function ItemDetailPage() {
   // Raw string: an empty box means "no content size", which is not the same as 0.
   const [contentQty, setContentQty] = useState("")
   const [contentUnit, setContentUnit] = useState<MeasureUnit | null>(null)
-  // Frontend-only: there's no warehouse field anywhere on the Item contract, so this
-  // isn't sent on save — nothing to wire it to server-side.
+  // Low-stock alert (saved as reorder rules via PUT /items/{id}/reorder, not on the item itself):
+  // alert level + reorder qty, watching `warehouseId` or, when null, every warehouse.
   const [warehouseId, setWarehouseId] = useState<number | null>(null)
+  const [lowStockAt, setLowStockAt] = useState("")
+  const [reorderQty, setReorderQty] = useState("")
+  // Selling prices change only through an approved price adjustment while approval is on (docs/DUAL_APPROVAL_PLAN.md §6.3).
+  const [pricesLocked, setPricesLocked] = useState(true)
+  const [priceHistory, setPriceHistory] = useState<ItemPriceHistory[] | null>(null)
 
   const [errors, setErrors] = useState<Record<string, string>>({})
   const [conflict, setConflict] = useState(false)
@@ -142,6 +170,10 @@ export default function ItemDetailPage() {
     setSellingFlatPrice(data.sellingFlatPrice === null ? "" : String(data.sellingFlatPrice))
     setContentQty(data.contentQty === null ? "" : String(data.contentQty))
     setContentUnit(data.contentUnit)
+    const alert = alertFromRules(data.reorder ?? [])
+    setLowStockAt(alert.lowStockAt)
+    setReorderQty(alert.reorderQty)
+    setWarehouseId(alert.warehouseId)
   }
 
   function load() {
@@ -168,6 +200,9 @@ export default function ItemDetailPage() {
       })
       .catch(() => {})
     productConfig().then((cfg) => setImagesEnabled(cfg.itemImagesEnabled)).catch(() => {})
+    // Locked unless Settings → Approvals turned price approval off; the server enforces it either way.
+    approvalsApi.getConfig().then((c) => setPricesLocked(c.priceAdjustmentLevels > 0)).catch(() => {})
+    priceAdjustmentsApi.itemHistory(itemId).then(setPriceHistory).catch(() => setPriceHistory([]))
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [itemId])
 
@@ -266,10 +301,23 @@ export default function ItemDetailPage() {
   async function handleSave() {
     if (!item || !etag) return
     setSaveError(null)
-    const nextErrors = validateItemForm({ sku, name, categoryId, baseUomId, contentQty, contentUnit })
+    const nextErrors: Record<string, string> = validateItemForm({ sku, name, categoryId, baseUomId, contentQty, contentUnit })
+    if (lowStockAt.trim()) {
+      const point = Number(lowStockAt)
+      const qty = Number(reorderQty)
+      if (Number.isNaN(point) || point < 0) nextErrors.lowStockAt = "Low stock alert must be 0 or more"
+      else if (stockNature !== "Stocked") nextErrors.lowStockAt = "Only stocked items hold stock — clear the low stock alert or make it Stocked"
+      if (!reorderQty.trim() || Number.isNaN(qty) || qty <= 0) nextErrors.reorderQty = "Enter how many to reorder (more than 0)"
+    }
     setErrors(nextErrors)
     if (Object.keys(nextErrors).length > 0) return
 
+    // Only rewrite the reorder rules when the alert fields were actually changed, so per-warehouse
+    // rules set under Reorder settings survive an unrelated edit (name, price, …).
+    const saved = alertFromRules(item.reorder ?? [])
+    const alertChanged =
+      lowStockAt.trim() !== saved.lowStockAt || (lowStockAt.trim() !== "" && (reorderQty.trim() !== saved.reorderQty || warehouseId !== saved.warehouseId))
+
     setSaving(true)
     try {
       const result = await itemsApi.update(
@@ -286,7 +334,21 @@ export default function ItemDetailPage() {
         },
         etag
       )
-      applyItem(result.data)
+      let saved = result.data
+      if (alertChanged) {
+        const watched = warehouseId !== null ? [warehouseId] : warehouses.map((w) => w.warehouseId)
+        const settings = lowStockAt.trim()
+          ? watched.map((id) => ({ warehouseId: id, reorderPoint: Number(lowStockAt), reorderQty: Number(reorderQty) }))
+          : []
+        try {
+          const res = await itemsApi.updateReorder(item.itemId, { settings })
+          saved = { ...saved, reorder: res.settings }
+        } catch (err) {
+          // The item itself is saved; say the alert wasn't, rather than failing the whole edit.
+          toast.warning("Item saved, but the low stock alert was not", errorMessage(err))
+        }
+      }
+      applyItem(saved)
       setEtag(result.etag)
       setEditOpen(false)
       setImagesVersion((v) => v + 1)
@@ -325,6 +387,12 @@ export default function ItemDetailPage() {
     }
   }
 
+  // Rules the simple alert fields can't show faithfully: levels that differ per warehouse, or
+  // several warehouses watched but not every one.
+  const savedRules = item?.reorder ?? []
+  const alertIsCustom =
+    !alertFromRules(savedRules).uniform || (savedRules.length > 1 && warehouses.length > 0 && savedRules.length < warehouses.length)
+
   function uomName(uomId: number) {
     return uoms.find((u) => u.uomId === uomId)?.name ?? `#${uomId}`
   }
@@ -420,16 +488,66 @@ export default function ItemDetailPage() {
           dialog closes so this copy picks up what changed there. */}
       <ItemImagesPanel key={imagesVersion} itemId={item.itemId} />
 
+      {/* Per-warehouse low-stock levels. Re-keyed on the saved rules so it picks up a change
+          made through the Edit dialog's simple alert fields. */}
       <ItemReorderPanel
-        key={item.itemId}
+        key={JSON.stringify(item.reorder ?? [])}
         itemId={item.itemId}
         stockNature={item.stockNature}
-        settings={item.reorder}
+        settings={item.reorder ?? []}
         warehouses={warehouses}
         uomName={uomName(item.baseUomId)}
-        onSaved={(settings) => setItem((prev) => (prev ? { ...prev, reorder: settings } : prev))}
+        onSaved={(settings) => applyItem({ ...item, reorder: settings })}
       />
 
+      {/* Every applied selling-price change and who approved it (docs/DUAL_APPROVAL_PLAN.md §6). */}
+      <div className="flex flex-col gap-3 rounded-xl border p-5">
+        <div className="flex flex-wrap items-center justify-between gap-2">
+          <h2 className="text-base font-semibold text-foreground">Price history</h2>
+          <Link href={`/dashboard/products/price-adjustments/new?itemId=${item.itemId}`} className="text-sm font-medium text-primary hover:underline">
+            Request price change
+          </Link>
+        </div>
+        {priceHistory === null ? (
+          <Skeleton className="h-20 w-full" />
+        ) : priceHistory.length === 0 ? (
+          <p className="py-4 text-center text-sm text-muted-foreground">No approved price changes yet.</p>
+        ) : (
+          <div className="overflow-x-auto">
+            <Table className="text-sm">
+              <TableHeader>
+                <TableRow>
+                  <TableHead className="h-9 px-2 text-xs">Applied</TableHead>
+                  <TableHead className="h-9 px-2 text-xs">Flat price</TableHead>
+                  <TableHead className="h-9 px-2 text-xs">Min / max</TableHead>
+                  <TableHead className="h-9 px-2 text-xs">Request</TableHead>
+                  <TableHead className="h-9 px-2 text-xs">Approved by</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {priceHistory.map((h) => (
+                  <TableRow key={h.itemPriceHistoryId}>
+                    <TableCell className="px-2 py-2 text-muted-foreground">{new Date(h.appliedAt).toLocaleDateString()}</TableCell>
+                    <TableCell className="px-2 py-2 tabular-nums">{fmtPrice(h.oldFlatPrice)} → <span className="font-semibold">{fmtPrice(h.newFlatPrice)}</span></TableCell>
+                    <TableCell className="px-2 py-2 tabular-nums text-muted-foreground">
+                      {fmtPrice(h.newMinPrice)} / {fmtPrice(h.newMaxPrice)}
+                    </TableCell>
+                    <TableCell className="px-2 py-2">
+                      {h.priceAdjustmentId ? (
+                        <Link href={`/dashboard/products/price-adjustments/${h.priceAdjustmentId}`} className="text-primary hover:underline">{h.docNo ?? `#${h.priceAdjustmentId}`}</Link>
+                      ) : "—"}
+                    </TableCell>
+                    <TableCell className="px-2 py-2 text-muted-foreground">
+                      {[h.approvedLevel1ByName, h.approvedLevel2ByName].filter(Boolean).join(", ") || "—"}
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+        )}
+      </div>
+
       <div className="grid grid-cols-1 gap-4 lg:grid-cols-2">
         <div className="flex flex-col gap-3 rounded-xl border p-5">
           <div className="flex items-center gap-2">
@@ -671,7 +789,7 @@ export default function ItemDetailPage() {
               onChange={(e) => setSellingMinPrice(e.target.value)}
               placeholder="Optional"
               className="h-12 text-base"
-              disabled={conflict}
+              disabled={conflict || pricesLocked}
             />
           </div>
           <div className="flex flex-col gap-2">
@@ -685,7 +803,7 @@ export default function ItemDetailPage() {
               onChange={(e) => setSellingMaxPrice(e.target.value)}
               placeholder="Optional"
               className="h-12 text-base"
-              disabled={conflict}
+              disabled={conflict || pricesLocked}
             />
           </div>
           <div className="flex flex-col gap-2">
@@ -699,8 +817,16 @@ export default function ItemDetailPage() {
               onChange={(e) => setSellingFlatPrice(e.target.value)}
               placeholder="Optional"
               className="h-12 text-base"
-              disabled={conflict}
+              disabled={conflict || pricesLocked}
             />
+            {pricesLocked && (
+              <p className="text-sm text-muted-foreground">
+                Selling prices need approval.{" "}
+                <Link href={`/dashboard/products/price-adjustments/new?itemId=${item.itemId}`} className="font-medium text-primary hover:underline">
+                  Request a price change
+                </Link>
+              </p>
+            )}
           </div>
           <div className="flex flex-col gap-2">
             <Label className="text-base">Tax rate</Label>
@@ -829,6 +955,50 @@ export default function ItemDetailPage() {
               </SelectContent>
             </Select>
           </div>
+          <div className="flex flex-col gap-2">
+            <Label className="text-base">Low stock alert (optional)</Label>
+            <div className="flex gap-2">
+              <Input
+                type="number"
+                min="0"
+                step="any"
+                inputMode="decimal"
+                value={lowStockAt}
+                onChange={(e) => setLowStockAt(e.target.value)}
+                placeholder="Alert when stock ≤"
+                aria-label="Alert when stock is at or below"
+                aria-invalid={!!errors.lowStockAt}
+                className="h-12! text-base"
+                disabled={conflict}
+              />
+              <Input
+                type="number"
+                min="0"
+                step="any"
+                inputMode="decimal"
+                value={reorderQty}
+                onChange={(e) => setReorderQty(e.target.value)}
+                placeholder="Reorder qty"
+                aria-label="Reorder quantity"
+                aria-invalid={!!errors.reorderQty}
+                className="h-12! text-base"
+                disabled={conflict}
+              />
+            </div>
+            <FieldError
+              errors={[
+                errors.lowStockAt ? { message: errors.lowStockAt } : undefined,
+                errors.reorderQty ? { message: errors.reorderQty } : undefined,
+              ]}
+            />
+            <p className="text-sm text-muted-foreground">
+              {alertIsCustom
+                ? "This item has its own per-warehouse levels (see Reorder settings). Changing these fields replaces them all with one level."
+                : lowStockAt.trim()
+                  ? `When stock at ${warehouseId ? (warehouses.find((w) => w.warehouseId === warehouseId)?.code ?? "the warehouse") : "any warehouse"} drops to ${lowStockAt} or less, a low-stock alert is sent.`
+                  : "When stock drops to this count or less, you get a low-stock alert. Clear it to stop alerts."}
+            </p>
+          </div>
           <div className="flex flex-col gap-2">
             <Label className="text-base">Warehouse (optional)</Label>
             <Select<number | null>
@@ -838,9 +1008,10 @@ export default function ItemDetailPage() {
               items={warehouses.map((w) => ({ label: `${w.code} — ${w.name}`, value: w.warehouseId }))}
             >
               <SelectTrigger className="h-12! w-full text-base">
-                <SelectValue placeholder="Select warehouse" />
+                <SelectValue placeholder="Every warehouse" />
               </SelectTrigger>
               <SelectContent>
+                <SelectItem value={null} className="text-base">Every warehouse</SelectItem>
                 {warehouses.map((w) => (
                   <SelectItem key={w.warehouseId} value={w.warehouseId} className="text-base">
                     {w.code} — {w.name}
@@ -848,6 +1019,7 @@ export default function ItemDetailPage() {
                 ))}
               </SelectContent>
             </Select>
+            <p className="text-sm text-muted-foreground">Where the low-stock alert watches stock.</p>
           </div>
         </div>
           <ItemImagesPanel itemId={item.itemId} editable canUpload={imagesEnabled} />
diff --git a/Frontend/erp-system/app/dashboard/products/new/page.tsx b/Frontend/erp-system/app/dashboard/products/new/page.tsx
index 161ad2f..ad38b2d 100644
--- a/Frontend/erp-system/app/dashboard/products/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/products/new/page.tsx
@@ -132,10 +132,14 @@ export default function NewItemPage() {
   const [subCategories, setSubCategories] = useState<SubCategory[]>([])
   const [subCategoryId, setSubCategoryId] = useState<number | null>(null)
   const [brandId, setBrandId] = useState<number | null>(null)
-  // Frontend-only: there's no warehouse field anywhere on the Item contract, so this
-  // isn't sent on submit — nothing to wire it to server-side.
+  // Items carry no warehouse; this picks which warehouse the low-stock alert below watches
+  // (none picked = every warehouse). Saved as reorder rules (PUT /items/{id}/reorder) after create.
   const [warehouses, setWarehouses] = useState<{ warehouseId: number; code: string; name: string }[]>([])
   const [warehouseId, setWarehouseId] = useState<number | null>(null)
+  // Low-stock alert (reorder point): when available stock falls to or below this, the item shows
+  // on Stock → Reorder Alerts and a "Low stock" notification is sent. Blank = no alert.
+  const [lowStockAt, setLowStockAt] = useState("")
+  const [reorderQty, setReorderQty] = useState("")
 
   const [checkedItemTypeIds, setCheckedItemTypeIds] = useState<number[]>([])
   const [valuesByCategory, setValuesByCategory] = useState<Record<number, DimensionValue[]>>({})
@@ -288,12 +292,24 @@ export default function NewItemPage() {
    */
   const productLabel = productName.trim()
 
+  /** Drops the given submit errors once the user edits the field they belong to. */
+  function clearErrors(...keys: string[]) {
+    setErrors((prev) => {
+      if (!keys.some((k) => prev[k])) return prev
+      const next = { ...prev }
+      for (const k of keys) delete next[k]
+      return next
+    })
+  }
+
   function handleCategoryChange(value: number | null) {
     setCategoryId(value)
     setSubCategoryId(null)
+    clearErrors("categoryId")
   }
 
   function toggleItemType(itemTypeId: number) {
+    clearErrors("variants", "measurable", "variantContent")
     setCheckedItemTypeIds((prev) =>
       prev.includes(itemTypeId) ? prev.filter((id) => id !== itemTypeId) : [...prev, itemTypeId]
     )
@@ -338,6 +354,7 @@ export default function NewItemPage() {
     }
     setItemOnlyWarrantyMonths(parsed.months)
     setWarrantyPeriodMonths(parsed.months)
+    clearErrors("warrantyPeriodMonths")
     closeCustomPeriod()
   }
 
@@ -549,6 +566,13 @@ export default function NewItemPage() {
     if (config?.warrantyPeriodsEnabled && warranty === "Warranty" && warrantyPeriodMonths === null) {
       nextErrors.warrantyPeriodMonths = "Select a warranty period"
     }
+    if (lowStockAt.trim()) {
+      const point = Number(lowStockAt)
+      const qty = Number(reorderQty)
+      if (Number.isNaN(point) || point < 0) nextErrors.lowStockAt = "Low stock alert must be 0 or more"
+      else if (stockNature !== "Stocked") nextErrors.lowStockAt = "Only stocked items hold stock — clear the low stock alert or make it Stocked"
+      if (!reorderQty.trim() || Number.isNaN(qty) || qty <= 0) nextErrors.reorderQty = "Enter how many to reorder (more than 0)"
+    }
     // Should never fire — addValue is the real gate — so it catches stale state only.
     const contentSweep = validateVariantContent(
       variants.map((v) => v.key),
@@ -567,9 +591,18 @@ export default function NewItemPage() {
     const nextPriceErrors =
       config?.sellingPricesEnabled && priceMode === "fixed" ? validateVariantPrices(variants.map((v) => v.key), priceFor) : {}
     setPriceErrors(nextPriceErrors)
-    if (Object.keys(nextErrors).length > 0 || Object.keys(nextPriceErrors).length > 0) return
+    const messages = [...new Set([...Object.values(nextErrors), ...Object.values(nextPriceErrors)])]
+    if (messages.length > 0) {
+      toast.error(
+        "Please fix the highlighted fields",
+        messages.length === 1 ? messages[0] : `${messages[0]} (and ${messages.length - 1} more)`,
+      )
+      return
+    }
     if (baseUomId === null) {
-      setSubmitError("No unit of measure exists yet — create one under Products → UOM before adding items.")
+      const message = "No unit of measure exists yet — create one under Products → UOM before adding items."
+      setSubmitError(message)
+      toast.error("Could not create item", message)
       return
     }
 
@@ -641,6 +674,21 @@ export default function NewItemPage() {
         if (failed > 0)
           toast.warning("Some images did not upload", `${failed} upload${failed === 1 ? "" : "s"} failed — add them from the item page.`)
       }
+
+      // Low-stock alert: one reorder rule per watched warehouse, per created item. Best-effort like
+      // images — the items exist either way, and the rules can be fixed under Reorder settings.
+      const watched = warehouseId !== null ? [warehouseId] : warehouses.map((w) => w.warehouseId)
+      if (lowStockAt.trim() && watched.length > 0) {
+        const settings = watched.map((id) => ({ warehouseId: id, reorderPoint: Number(lowStockAt), reorderQty: Number(reorderQty) }))
+        let failed = 0
+        for (const itemId of createdIds) {
+          await itemsApi.updateReorder(itemId, { settings }).catch(() => {
+            failed += 1
+          })
+        }
+        if (failed > 0)
+          toast.warning("Low stock alert not saved for every item", `${failed} item${failed === 1 ? "" : "s"} failed — set it under the item's Reorder settings.`)
+      }
       router.push("/dashboard/products")
     } catch (err) {
       // Each row is its own POST with no transaction, so a failure partway (e.g. a
@@ -689,10 +737,13 @@ export default function NewItemPage() {
         <>
           <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
             <div className="flex flex-col gap-2">
-              <Label className="text-base">Product name</Label>
+              <Label className="text-base" required>Product name</Label>
               <Input
                 value={productName}
-                onChange={(e) => setProductName(e.target.value)}
+                onChange={(e) => {
+                  setProductName(e.target.value)
+                  clearErrors("productName")
+                }}
                 placeholder="e.g. Coca Cola"
                 aria-invalid={!!errors.productName}
                 className="h-12! text-base"
@@ -705,7 +756,7 @@ export default function NewItemPage() {
             </div>
 
             <div className="flex flex-col gap-2">
-              <Label className="text-base">Category</Label>
+              <Label className="text-base" required>Category</Label>
               <Select<number | null>
                 value={categoryId}
                 onValueChange={handleCategoryChange}
@@ -769,6 +820,52 @@ export default function NewItemPage() {
                 </Select>
               </div>
             )}
+            <div className="flex flex-col gap-2">
+              <Label className="text-base">Low stock alert (optional)</Label>
+              <div className="flex gap-2">
+                <Input
+                  type="number"
+                  min="0"
+                  step="any"
+                  inputMode="decimal"
+                  value={lowStockAt}
+                  onChange={(e) => {
+                    setLowStockAt(e.target.value)
+                    clearErrors("lowStockAt", "reorderQty")
+                  }}
+                  placeholder="Alert when stock ≤"
+                  aria-label="Alert when stock is at or below"
+                  aria-invalid={!!errors.lowStockAt}
+                  className="h-12! text-base"
+                />
+                <Input
+                  type="number"
+                  min="0"
+                  step="any"
+                  inputMode="decimal"
+                  value={reorderQty}
+                  onChange={(e) => {
+                    setReorderQty(e.target.value)
+                    clearErrors("reorderQty")
+                  }}
+                  placeholder="Reorder qty"
+                  aria-label="Reorder quantity"
+                  aria-invalid={!!errors.reorderQty}
+                  className="h-12! text-base"
+                />
+              </div>
+              <FieldError
+                errors={[
+                  errors.lowStockAt ? { message: errors.lowStockAt } : undefined,
+                  errors.reorderQty ? { message: errors.reorderQty } : undefined,
+                ]}
+              />
+              <p className="text-sm text-muted-foreground">
+                {lowStockAt.trim()
+                  ? `When stock at ${warehouseId ? (warehouses.find((w) => w.warehouseId === warehouseId)?.code ?? "the warehouse") : "any warehouse"} drops to ${lowStockAt} or less, a low-stock alert is sent and the item shows on Reorder Alerts.`
+                  : "When stock drops to this count or less, you get a low-stock alert. Leave blank for no alert."}
+              </p>
+            </div>
             <div className="flex flex-col gap-2">
               <Label className="text-base">Warehouse (optional)</Label>
               <Select<number | null>
@@ -787,9 +884,10 @@ export default function NewItemPage() {
                   ))}
                 </SelectContent>
               </Select>
+              <p className="text-sm text-muted-foreground">Where the low-stock alert watches stock. None picked = every warehouse.</p>
             </div>
             <div className="flex flex-col gap-2">
-              <Label className="text-base">Base UOM</Label>
+              <Label className="text-base" required>Base UOM</Label>
               <Select<number | null>
                 value={baseUomId}
                 onValueChange={setBaseUomId}
@@ -846,14 +944,20 @@ export default function NewItemPage() {
                   min="0"
                   step="any"
                   value={contentQty}
-                  onChange={(e) => setContentQty(e.target.value)}
+                  onChange={(e) => {
+                    setContentQty(e.target.value)
+                    clearErrors("contentQty", "contentUnit")
+                  }}
                   placeholder="e.g. 500"
                   aria-invalid={!!errors.contentQty}
                   className="h-12! text-base"
                 />
                 <Select<MeasureUnit | null>
                   value={contentUnit}
-                  onValueChange={setContentUnit}
+                  onValueChange={(v) => {
+                    setContentUnit(v)
+                    clearErrors("contentQty", "contentUnit")
+                  }}
                   items={CONTENT_UNITS.map((u) => ({ label: u, value: u }))}
                 >
                   <SelectTrigger className="h-12! w-28 shrink-0 text-base" aria-invalid={!!errors.contentUnit}>
@@ -1004,7 +1108,10 @@ export default function NewItemPage() {
                     value={warranty}
                     onValueChange={(v) => {
                       setWarranty(v as typeof warranty)
-                      if (v === "NonWarranty") setWarrantyPeriodMonths(null)
+                      if (v === "NonWarranty") {
+                        setWarrantyPeriodMonths(null)
+                        clearErrors("warrantyPeriodMonths")
+                      }
                     }}
                     className="flex flex-col gap-3"
                   >
@@ -1020,10 +1127,14 @@ export default function NewItemPage() {
 
                   {warranty === "Warranty" && (
                     <div className="mt-2 flex flex-col gap-1.5">
-                      <Label>Warranty period +</Label>
+                      <Label required>Warranty period +</Label>
                       <Select<WarrantyPeriodMonths>
                         value={warrantyPeriodMonths}
-                        onValueChange={(v) => v && setWarrantyPeriodMonths(v)}
+                        onValueChange={(v) => {
+                          if (!v) return
+                          setWarrantyPeriodMonths(v)
+                          clearErrors("warrantyPeriodMonths")
+                        }}
                         items={warrantySelectGroups.flatMap((g) => g.months).map((m) => ({
                           label: formatWarrantyPeriod(m),
                           value: m,
diff --git a/Frontend/erp-system/app/dashboard/products/price-adjustments/[id]/page.tsx b/Frontend/erp-system/app/dashboard/products/price-adjustments/[id]/page.tsx
new file mode 100644
index 0000000..c9e1646
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/products/price-adjustments/[id]/page.tsx
@@ -0,0 +1,173 @@
+"use client"
+
+import { use, useEffect, useState } from "react"
+import Link from "next/link"
+import { AlertTriangle, ArrowLeft } from "lucide-react"
+
+import { priceAdjustmentsApi } from "@/lib/api/approvals"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { PriceAdjustment, PriceAdjustmentLine } from "@/types/approvals"
+
+import { ApprovalPanel, PriceAdjustmentStatusBadge } from "@/components/approvals/ApprovalPanel"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { toast } from "@/components/ui/toast"
+
+const price = (v: number | null) => (v === null ? "—" : formatAmount(v))
+
+/** True while pending and the item has been repriced since the request — approving would be refused. */
+function isStale(l: PriceAdjustmentLine) {
+  return l.currentMinPrice !== l.oldMinPrice || l.currentMaxPrice !== l.oldMaxPrice || l.currentFlatPrice !== l.oldFlatPrice
+}
+
+/** One price change request: old → new per item, the approval trail, and the actions (docs/DUAL_APPROVAL_PLAN.md §6). */
+export default function PriceAdjustmentDetailPage({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = use(params)
+  const priceAdjustmentId = Number(id)
+  const [adjustment, setAdjustment] = useState<PriceAdjustment | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const error = Number.isFinite(priceAdjustmentId) ? loadError : `Invalid request id '${id}'.`
+
+  useEffect(() => {
+    if (!Number.isFinite(priceAdjustmentId)) return
+    priceAdjustmentsApi.get(priceAdjustmentId).then(setAdjustment).catch((err) => setLoadError(errorMessage(err)))
+  }, [priceAdjustmentId])
+
+  if (error) {
+    return (
+      <div className="flex flex-col gap-4">
+        <BackLink />
+        <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+      </div>
+    )
+  }
+  if (!adjustment) return <Skeleton className="h-96 w-full" />
+
+  const p = adjustment
+  const pending = p.pendingLevel !== null
+  const outcome = p.status === "Approved" ? "applied" : p.status === "Rejected" ? "rejected" : p.status === "Cancelled" ? "withdrawn" : "pending"
+  const staleLines = pending ? p.lines.filter(isStale) : []
+
+  return (
+    <div className="flex flex-col gap-6">
+      <BackLink />
+      <div className="flex flex-col gap-2">
+        <div className="flex flex-wrap items-center gap-3">
+          <h1 className="text-2xl font-bold text-foreground">{p.docNo}</h1>
+          <PriceAdjustmentStatusBadge status={p.status} />
+        </div>
+        <p className="text-base text-muted-foreground">{p.reason}</p>
+        {pending && <p className="text-sm text-warning">Prices have not changed yet — they change when this request is fully approved.</p>}
+      </div>
+
+      {staleLines.length > 0 && (
+        <div className="flex items-start gap-2 rounded-lg border border-warning/30 bg-warning/5 p-4 text-sm text-warning">
+          <AlertTriangle className="size-4 shrink-0" />
+          <span>
+            {staleLines.map((l) => l.sku).join(", ")} {staleLines.length === 1 ? "was" : "were"} repriced after this request was made, so it can no longer be approved.
+            Reject it and raise a new request against the current prices.
+          </span>
+        </div>
+      )}
+
+      <div className="grid grid-cols-1 gap-6 lg:grid-cols-[1fr_24rem]">
+        <div className="overflow-x-auto rounded-xl border">
+          <Table className="text-sm">
+            <TableHeader>
+              <TableRow>
+                <TableHead className="px-3">Item</TableHead>
+                <TableHead className="px-3 text-right">Min</TableHead>
+                <TableHead className="px-3 text-right">Max</TableHead>
+                <TableHead className="px-3 text-right">Flat</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {p.lines.map((l) => (
+                <TableRow key={l.priceAdjustmentLineId} className={cn(pending && isStale(l) && "bg-warning/5")}>
+                  <TableCell className="px-3 py-2">
+                    <Link href={`/dashboard/products/${l.itemId}`} className="font-medium hover:underline">{l.sku}</Link>
+                    <p className="text-xs text-muted-foreground">{l.itemName}</p>
+                  </TableCell>
+                  <Change from={l.oldMinPrice} to={l.newMinPrice} />
+                  <Change from={l.oldMaxPrice} to={l.newMaxPrice} />
+                  <Change from={l.oldFlatPrice} to={l.newFlatPrice} />
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </div>
+
+        <ApprovalPanel
+          what="price adjustment"
+          requiredApprovals={p.requiredApprovals}
+          pendingLevel={p.pendingLevel}
+          history={p.approvalHistory}
+          requestedByLabel={p.createdByName ?? `user #${p.createdBy}`}
+          requestedAt={p.createdAt}
+          canApprove={p.canApprove}
+          whyNot={p.whyNot}
+          canWithdraw={p.canWithdraw}
+          finalEffect="The new prices take effect on the items straight away."
+          outcome={outcome}
+          outcomeAt={p.appliedAt}
+          rejectReason={p.rejectReason}
+          onApprove={async (comment) => {
+            try {
+              const next = await priceAdjustmentsApi.approve(p.priceAdjustmentId, comment)
+              setAdjustment(next)
+              toast.success(next.status === "Approved" ? "Approved — prices applied" : "Approved", next.status === "Approved" ? `${next.docNo} is in effect.` : `${next.docNo} now needs a second approval.`)
+            } catch (err) {
+              toast.error("Could not approve", errorMessage(err))
+              throw err
+            }
+          }}
+          onReject={async (reason) => {
+            try {
+              setAdjustment(await priceAdjustmentsApi.reject(p.priceAdjustmentId, reason))
+              toast.success("Request rejected", p.docNo)
+            } catch (err) {
+              toast.error("Could not reject", errorMessage(err))
+              throw err
+            }
+          }}
+          onWithdraw={async () => {
+            try {
+              setAdjustment(await priceAdjustmentsApi.cancel(p.priceAdjustmentId))
+              toast.success("Request withdrawn", p.docNo)
+            } catch (err) {
+              toast.error("Could not withdraw", errorMessage(err))
+              throw err
+            }
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function Change({ from, to }: { from: number | null; to: number | null }) {
+  const changed = from !== to
+  return (
+    <TableCell className="px-3 py-2 text-right tabular-nums">
+      {changed ? (
+        <>
+          <span className="text-muted-foreground line-through">{price(from)}</span>
+          <span className="ml-2 font-semibold text-foreground">{price(to)}</span>
+        </>
+      ) : (
+        <span className="text-muted-foreground">{price(from)}</span>
+      )}
+    </TableCell>
+  )
+}
+
+function BackLink() {
+  return (
+    <Link href="/dashboard/products/price-adjustments" className="inline-flex w-fit items-center gap-1.5 text-sm font-medium text-muted-foreground hover:text-foreground">
+      <ArrowLeft className="size-4" />
+      Price Adjustments
+    </Link>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/products/price-adjustments/new/page.tsx b/Frontend/erp-system/app/dashboard/products/price-adjustments/new/page.tsx
new file mode 100644
index 0000000..9e46f67
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/products/price-adjustments/new/page.tsx
@@ -0,0 +1,388 @@
+"use client"
+
+import { Suspense, useEffect, useState } from "react"
+import Link from "next/link"
+import { useRouter, useSearchParams } from "next/navigation"
+import { ArrowLeft, ArrowRight, Send } from "lucide-react"
+
+import { priceAdjustmentsApi } from "@/lib/api/approvals"
+import { itemsApi } from "@/lib/api/items"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount } from "@/lib/format"
+import { cn } from "@/lib/utils"
+import { Item, ItemPurchasePrice } from "@/types/master-data"
+
+import { Button, buttonVariants } from "@/components/ui/button"
+import { Combobox, ComboboxOption } from "@/components/ui/combobox"
+import { Field, FieldError, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Textarea } from "@/components/ui/textarea"
+import { toast } from "@/components/ui/toast"
+
+type PriceKey = "min" | "max" | "flat"
+const PRICE_FIELDS: { key: PriceKey; label: string; hint: string }[] = [
+  { key: "flat", label: "Selling price (flat)", hint: "The price sales use by default" },
+  { key: "min", label: "Minimum price", hint: "Lowest a cashier may sell at" },
+  { key: "max", label: "Maximum price", hint: "Highest a cashier may sell at" },
+]
+
+const asInput = (v: number | null) => (v === null ? "" : String(v))
+const asPrice = (v: string) => (v.trim() === "" ? null : Number(v))
+const current = (item: Item, key: PriceKey) =>
+  key === "min" ? item.sellingMinPrice : key === "max" ? item.sellingMaxPrice : item.sellingFlatPrice
+
+export default function NewPriceAdjustmentPage() {
+  // useSearchParams needs a Suspense boundary, or the production build can't prerender the route.
+  return (
+    <Suspense>
+      <NewPriceAdjustmentForm />
+    </Suspense>
+  )
+}
+
+/**
+ * Request a selling-price change (docs/DUAL_APPROVAL_PLAN.md §6), step by step:
+ * 1. select the item, 2. see its current prices, 3. enter the new prices, 4. give a reason, 5. submit for approval.
+ * Prices don't change until the request is approved. Opening with ?itemId=… starts on that item.
+ */
+function NewPriceAdjustmentForm() {
+  const router = useRouter()
+  const searchParams = useSearchParams()
+
+  const [item, setItem] = useState<Item | null>(null)
+  const [loadingItem, setLoadingItem] = useState(false)
+  const [options, setOptions] = useState<ComboboxOption<number>[] | null>(null)
+  const [prices, setPrices] = useState<Record<PriceKey, string>>({ min: "", max: "", flat: "" })
+  const [reason, setReason] = useState("")
+  const [errors, setErrors] = useState<Record<string, string>>({})
+  const [saving, setSaving] = useState(false)
+
+  // The item's latest GRN purchase prices, to price against (null while loading).
+  const [purchases, setPurchases] = useState<ItemPurchasePrice[] | null>(null)
+
+  function choose(data: Item) {
+    setItem(data)
+    setPrices({ min: asInput(data.sellingMinPrice), max: asInput(data.sellingMaxPrice), flat: asInput(data.sellingFlatPrice) })
+    setErrors({})
+    setPurchases(null)
+    itemsApi.purchasePrices(data.itemId).then(setPurchases).catch(() => setPurchases([]))
+  }
+
+  const lastCost = purchases && purchases.length > 0 ? purchases[0].netUnitCost : null
+
+  function selectItem(itemId: number | null) {
+    if (itemId === null) {
+      setItem(null)
+      return
+    }
+    if (itemId === item?.itemId) return
+    setLoadingItem(true)
+    itemsApi
+      .get(itemId)
+      .then(({ data }) => choose(data))
+      .catch((err) => toast.error("Could not load the item", errorMessage(err)))
+      .finally(() => setLoadingItem(false))
+  }
+
+  // Came from an item's "Request price change": start on that item.
+  const preselect = Number(searchParams.get("itemId"))
+  useEffect(() => {
+    if (!Number.isFinite(preselect) || preselect <= 0) return
+    itemsApi
+      .get(preselect)
+      .then(({ data }) => choose(data))
+      .catch((err) => toast.error("Could not load the item", errorMessage(err)))
+  }, [preselect])
+
+  // Every active item for the dropdown (the list endpoint caps a page at 200, so page through).
+  useEffect(() => {
+    let cancelled = false
+    ;(async () => {
+      const all: ComboboxOption<number>[] = []
+      for (let page = 1; page <= 25; page++) {
+        const res = await itemsApi.list({ status: "Active", page, pageSize: 200 })
+        all.push(...res.items.map((i) => ({ value: i.itemId, label: `${i.sku} — ${i.name}` })))
+        if (page >= res.pagination.totalPages) break
+      }
+      if (!cancelled) setOptions(all.sort((a, b) => a.label.localeCompare(b.label)))
+    })().catch((err) => {
+      if (!cancelled) {
+        setOptions([])
+        toast.error("Could not load items", errorMessage(err))
+      }
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  function validate(): Record<string, string> {
+    const next: Record<string, string> = {}
+    if (!item) {
+      next.item = "Select an item first"
+      return next
+    }
+    const [min, max, flat] = [asPrice(prices.min), asPrice(prices.max), asPrice(prices.flat)]
+    if ([min, max, flat].some((v) => v !== null && (Number.isNaN(v) || v < 0))) next.prices = "Prices must be 0 or more"
+    else if (min !== null && max !== null && min > max) next.prices = "The minimum price is above the maximum"
+    else if (flat !== null && ((min !== null && flat < min) || (max !== null && flat > max))) next.prices = "The selling price must be between the minimum and maximum"
+    else if (min === item.sellingMinPrice && max === item.sellingMaxPrice && flat === item.sellingFlatPrice) next.prices = "Enter at least one new price"
+    if (!reason.trim()) next.reason = "Say why the price is changing"
+    return next
+  }
+
+  async function submit() {
+    const next = validate()
+    setErrors(next)
+    if (Object.keys(next).length > 0 || !item) return
+    setSaving(true)
+    try {
+      const created = await priceAdjustmentsApi.create({
+        reason: reason.trim(),
+        lines: [{ itemId: item.itemId, newMinPrice: asPrice(prices.min), newMaxPrice: asPrice(prices.max), newFlatPrice: asPrice(prices.flat) }],
+      })
+      toast.success(
+        created.status === "Approved" ? "Price updated" : "Sent for approval",
+        created.status === "Approved"
+          ? `${created.docNo} applied.`
+          : `${created.docNo} — the new price takes effect once ${created.requiredApprovals === 2 ? "two people approve it" : "it is approved"}.`
+      )
+      router.push(`/dashboard/products/price-adjustments/${created.priceAdjustmentId}`)
+    } catch (err) {
+      toast.error("Could not send the price change", errorMessage(err))
+      setSaving(false)
+    }
+  }
+
+  return (
+    <div className="flex flex-col gap-6">
+      <Link href="/dashboard/products/price-adjustments" className="inline-flex w-fit items-center gap-1.5 text-sm font-medium text-muted-foreground hover:text-foreground">
+        <ArrowLeft className="size-4" />
+        Price Adjustments
+      </Link>
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Request price change</h1>
+        <p className="text-base text-muted-foreground">The item keeps its current price until this request is approved.</p>
+      </div>
+
+      <div className="flex max-w-3xl flex-col gap-5">
+        {/* 1. Item */}
+        <Step number={1} title="Select the item" done={!!item}>
+          {options === null ? (
+            <Skeleton className="h-12 w-full" />
+          ) : (
+            <div className="flex flex-col gap-2">
+              <Combobox<number>
+                items={
+                  // Keep the chosen item listed even if it isn't active (came in via ?itemId=…).
+                  item && !options.some((o) => o.value === item.itemId)
+                    ? [{ value: item.itemId, label: `${item.sku} — ${item.name}` }, ...options]
+                    : options
+                }
+                value={item?.itemId ?? null}
+                onValueChange={selectItem}
+                placeholder="Select an item — type to search by SKU or name"
+                emptyText="No matching active items."
+                className="h-12 text-base"
+                aria-invalid={!!errors.item}
+              />
+              {loadingItem && <p className="text-sm text-muted-foreground">Loading the item’s prices…</p>}
+              <FieldError errors={[errors.item ? { message: errors.item } : undefined]} />
+            </div>
+          )}
+        </Step>
+
+        {/* 2. Current price */}
+        <Step number={2} title="Current price" muted={!item}>
+          {item ? (
+            <div className="flex flex-col gap-4">
+              <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
+                {PRICE_FIELDS.map((f) => (
+                  <div key={f.key} className="rounded-lg border p-3">
+                    <p className="text-xs text-muted-foreground">{f.label}</p>
+                    <p className="text-lg font-bold tabular-nums text-foreground">{priceText(current(item, f.key))}</p>
+                  </div>
+                ))}
+                <div className="rounded-lg border border-primary/30 bg-primary/5 p-3">
+                  <p className="text-xs text-muted-foreground">Last GRN cost</p>
+                  {purchases === null ? (
+                    <Skeleton className="mt-1 h-6 w-24" />
+                  ) : (
+                    <>
+                      <p className="text-lg font-bold tabular-nums text-foreground">{priceText(lastCost)}</p>
+                      <p className="text-xs text-muted-foreground">
+                        {lastCost === null ? "Never received" : <Margin price={item.sellingFlatPrice} cost={lastCost} label="Margin now" />}
+                      </p>
+                    </>
+                  )}
+                </div>
+              </div>
+
+              {/* What it was bought at recently — the cost side of the new price. */}
+              {purchases !== null && purchases.length > 0 && (
+                <div className="overflow-x-auto rounded-lg border">
+                  <table className="w-full text-sm">
+                    <thead className="bg-muted/40 text-xs text-muted-foreground">
+                      <tr>
+                        <th className="px-3 py-2 text-left font-medium">GRN</th>
+                        <th className="px-3 py-2 text-left font-medium">Received</th>
+                        <th className="px-3 py-2 text-left font-medium">Vendor</th>
+                        <th className="px-3 py-2 text-right font-medium">Qty</th>
+                        <th className="px-3 py-2 text-right font-medium">Unit cost</th>
+                        <th className="px-3 py-2 text-right font-medium">Disc.</th>
+                        <th className="px-3 py-2 text-right font-medium">Net cost</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {purchases.map((p, i) => (
+                        <tr key={`${p.grnId}-${i}`} className="border-t">
+                          <td className="px-3 py-2">
+                            <Link href={`/dashboard/receiving/grn/${p.grnId}`} className="text-primary hover:underline">{p.grnDocNo}</Link>
+                          </td>
+                          <td className="px-3 py-2 text-muted-foreground">{new Date(p.receivedAt).toLocaleDateString()}</td>
+                          <td className="px-3 py-2">{p.vendorName ?? `#${p.vendorId}`}</td>
+                          <td className="px-3 py-2 text-right tabular-nums">{p.qty}</td>
+                          <td className="px-3 py-2 text-right tabular-nums">{formatAmount(p.unitCost)}</td>
+                          <td className="px-3 py-2 text-right tabular-nums text-muted-foreground">{p.discountPct ? `${p.discountPct}%` : "—"}</td>
+                          <td className="px-3 py-2 text-right font-semibold tabular-nums">{formatAmount(p.netUnitCost)}</td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                  <p className="border-t px-3 py-2 text-xs text-muted-foreground">
+                    Net cost = unit cost after discount, excluding VAT (the stock cost). Latest {purchases.length} receipt{purchases.length === 1 ? "" : "s"}.
+                  </p>
+                </div>
+              )}
+            </div>
+          ) : (
+            <p className="text-sm text-muted-foreground">Shown once you select an item.</p>
+          )}
+        </Step>
+
+        {/* 3. New price */}
+        <Step number={3} title="New price" muted={!item}>
+          {item ? (
+            <div className="flex flex-col gap-3">
+              <div className="grid grid-cols-1 gap-3 sm:grid-cols-3">
+                {PRICE_FIELDS.map((f) => {
+                  const now = current(item, f.key)
+                  const next = asPrice(prices[f.key])
+                  const changed = next !== now && !(next !== null && Number.isNaN(next))
+                  return (
+                    <Field key={f.key}>
+                      <FieldLabel htmlFor={`new-${f.key}`}>{f.label}</FieldLabel>
+                      <Input
+                        id={`new-${f.key}`}
+                        type="number"
+                        min="0"
+                        step="0.01"
+                        inputMode="decimal"
+                        value={prices[f.key]}
+                        onChange={(e) => { setPrices((p) => ({ ...p, [f.key]: e.target.value })); setErrors((x) => ({ ...x, prices: "" })) }}
+                        placeholder="No price"
+                        aria-invalid={!!errors.prices}
+                        className={cn("h-11 text-base tabular-nums", changed && "border-primary")}
+                      />
+                      <p className="text-xs text-muted-foreground">
+                        {changed ? <ChangeText from={now} to={next} /> : f.hint}
+                      </p>
+                    </Field>
+                  )
+                })}
+              </div>
+              <FieldError errors={[errors.prices ? { message: errors.prices } : undefined]} />
+              {lastCost !== null && asPrice(prices.flat) !== null && !Number.isNaN(asPrice(prices.flat)) && (
+                <p className="text-sm">
+                  <Margin price={asPrice(prices.flat)} cost={lastCost} label="Margin at the new selling price" />
+                  {asPrice(prices.flat)! < lastCost && <span className="ml-2 font-medium text-destructive">— below the last GRN cost</span>}
+                </p>
+              )}
+            </div>
+          ) : (
+            <p className="text-sm text-muted-foreground">Select an item first.</p>
+          )}
+        </Step>
+
+        {/* 4. Reason */}
+        <Step number={4} title="Reason" muted={!item}>
+          <Field data-invalid={!!errors.reason}>
+            <FieldLabel htmlFor="pa-reason" className="sr-only">Reason</FieldLabel>
+            <Textarea
+              id="pa-reason"
+              rows={3}
+              maxLength={250}
+              value={reason}
+              disabled={!item}
+              onChange={(e) => { setReason(e.target.value); setErrors((x) => ({ ...x, reason: "" })) }}
+              placeholder="e.g. Supplier price increase from 1 November"
+            />
+            <FieldError errors={[errors.reason ? { message: errors.reason } : undefined]} />
+          </Field>
+        </Step>
+
+        {/* 5. Send for approval */}
+        <div className="flex flex-col-reverse gap-2 sm:flex-row sm:items-center sm:justify-between">
+          <p className="text-sm text-muted-foreground">Approvers are notified. The price changes only after approval.</p>
+          <div className="flex gap-2">
+            <Link href="/dashboard/products/price-adjustments" className={cn(buttonVariants({ variant: "outline", size: "lg" }))}>Cancel</Link>
+            <Button size="lg" onClick={submit} disabled={!item || saving}>
+              <Send className="size-4" />
+              {saving ? "Sending…" : "Send for approval"}
+            </Button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function priceText(v: number | null) {
+  return v === null ? "—" : `LKR ${formatAmount(v)}`
+}
+
+/** "Margin now: LKR 30.00 (25.0%)" — selling price over the last GRN net cost, red when negative. */
+function Margin({ price, cost, label }: { price: number | null; cost: number; label: string }) {
+  if (price === null) return <span className="text-muted-foreground">{label}: no selling price</span>
+  const margin = price - cost
+  const pct = price === 0 ? null : (margin / price) * 100
+  return (
+    <span className={cn(margin < 0 ? "text-destructive" : "text-success")}>
+      {label}: LKR {formatAmount(margin)}
+      {pct !== null && ` (${pct.toFixed(1)}%)`}
+    </span>
+  )
+}
+
+/** "100.00 → 120.00 (+20%)", or how a price is being set / cleared. */
+function ChangeText({ from, to }: { from: number | null; to: number | null }) {
+  if (from === null) return <span className="text-primary">New price: {priceText(to)}</span>
+  if (to === null) return <span className="text-warning">Price will be cleared</span>
+  const pct = from === 0 ? null : ((to - from) / from) * 100
+  return (
+    <span className={cn(to > from ? "text-success" : "text-destructive")}>
+      {formatAmount(from)} <ArrowRight className="inline size-3" /> {formatAmount(to)}
+      {pct !== null && ` (${pct > 0 ? "+" : ""}${pct.toFixed(1)}%)`}
+    </span>
+  )
+}
+
+function Step({ number, title, done, muted, children }: { number: number; title: string; done?: boolean; muted?: boolean; children: React.ReactNode }) {
+  return (
+    <section className={cn("flex flex-col gap-3 rounded-2xl border bg-card p-4 shadow-sm sm:p-5", muted && "opacity-60")}>
+      <div className="flex items-center gap-3">
+        <span
+          className={cn(
+            "flex size-7 shrink-0 items-center justify-center rounded-full text-sm font-semibold",
+            done ? "bg-success/15 text-success" : "bg-primary/10 text-primary"
+          )}
+        >
+          {number}
+        </span>
+        <h2 className="text-base font-semibold text-foreground">{title}</h2>
+      </div>
+      {children}
+    </section>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/products/price-adjustments/page.tsx b/Frontend/erp-system/app/dashboard/products/price-adjustments/page.tsx
new file mode 100644
index 0000000..b8992b0
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/products/price-adjustments/page.tsx
@@ -0,0 +1,146 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import Link from "next/link"
+import { useRouter } from "next/navigation"
+import { Plus, Search, Tag } from "lucide-react"
+
+import { priceAdjustmentsApi } from "@/lib/api/approvals"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { PriceAdjustmentStatus, PriceAdjustmentSummary } from "@/types/approvals"
+import { PaginationMeta } from "@/types/common"
+
+import { PriceAdjustmentStatusBadge } from "@/components/approvals/ApprovalPanel"
+import { ApprovalQueueButton } from "@/components/approvals/ApprovalQueueButton"
+import { buttonVariants } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+
+type StatusFilter = PriceAdjustmentStatus | "All"
+const statusOptions: { value: StatusFilter; label: string }[] = [
+  { value: "All", label: "All statuses" },
+  { value: "PendingApproval", label: "Pending 1st approval" },
+  { value: "PendingSecondApproval", label: "Pending 2nd approval" },
+  { value: "Approved", label: "Applied" },
+  { value: "Rejected", label: "Rejected" },
+  { value: "Cancelled", label: "Withdrawn" },
+]
+const PAGE_SIZE_OPTIONS = [10, 20, 50]
+
+/** Selling-price change requests (docs/DUAL_APPROVAL_PLAN.md §6). Prices change only once a request is fully approved. */
+export default function PriceAdjustmentsPage() {
+  const router = useRouter()
+  const [rows, setRows] = useState<PriceAdjustmentSummary[] | null>(null)
+  const [pagination, setPagination] = useState<PaginationMeta | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [searchInput, setSearchInput] = useState("")
+  const [query, setQuery] = useState("")
+  const [status, setStatus] = useState<StatusFilter>("All")
+  const [page, setPage] = useState(1)
+  const [pageSize, setPageSize] = useState(PAGE_SIZE_OPTIONS[0])
+
+  useEffect(() => {
+    const timeout = setTimeout(() => setQuery(searchInput.trim()), 300)
+    return () => clearTimeout(timeout)
+  }, [searchInput])
+
+  useEffect(() => {
+    priceAdjustmentsApi
+      .list({ page, pageSize, q: query || undefined, status: status === "All" ? undefined : status })
+      .then((res) => {
+        setRows(res.items)
+        setPagination(res.pagination)
+        setError(null)
+      })
+      .catch((err) => setError(errorMessage(err)))
+  }, [page, pageSize, query, status])
+
+  const open = (id: number) => router.push(`/dashboard/products/price-adjustments/${id}`)
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+        <div>
+          <h1 className="text-2xl font-bold text-foreground">Price Adjustments</h1>
+          <p className="text-base text-muted-foreground">
+            Requests to change selling prices. A new price takes effect only after it is approved — twice, by two different people, when dual approval is on.
+          </p>
+        </div>
+        <div className="flex flex-col gap-2 sm:flex-row">
+          <ApprovalQueueButton docType="PADJ" />
+          <Link href="/dashboard/products/price-adjustments/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
+            <Plus className="size-5" />
+            Request price change
+          </Link>
+        </div>
+      </div>
+
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center">
+        <div className="relative flex-1">
+          <Search className="pointer-events-none absolute top-1/2 left-4 size-5 -translate-y-1/2 text-muted-foreground" />
+          <Input
+            value={searchInput}
+            onChange={(e) => { setSearchInput(e.target.value); setPage(1) }}
+            placeholder="Search doc no. or reason…"
+            className="h-12 w-full pl-11 text-base"
+            aria-label="Search price adjustments"
+          />
+        </div>
+        <Select<StatusFilter> value={status} onValueChange={(v) => { setStatus(v ?? "All"); setPage(1) }}>
+          <SelectTrigger className="h-12! w-full text-base sm:w-56" aria-label="Status"><SelectValue /></SelectTrigger>
+          <SelectContent>
+            {statusOptions.map((o) => <SelectItem key={o.value} value={o.value} className="text-base">{o.label}</SelectItem>)}
+          </SelectContent>
+        </Select>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!error && rows === null && <Skeleton className="h-64 w-full" />}
+      {!error && rows !== null && rows.length === 0 && (
+        <div className="flex flex-col items-center gap-4 rounded-xl border border-dashed py-20 text-center">
+          <Tag className="size-12 text-muted-foreground" />
+          <p className="text-base text-muted-foreground">No price adjustments{status !== "All" || query ? " match your filters" : " yet"}.</p>
+        </div>
+      )}
+
+      {!error && rows !== null && rows.length > 0 && (
+        <>
+          <div className="overflow-x-auto rounded-xl border">
+            <Table className="text-base">
+              <TableHeader>
+                <TableRow>
+                  <TableHead className="h-12 px-3 text-sm">Request</TableHead>
+                  <TableHead className="h-12 px-3 text-sm">Reason</TableHead>
+                  <TableHead className="h-12 px-3 text-right text-sm">Items</TableHead>
+                  <TableHead className="h-12 px-3 text-sm">Requested by</TableHead>
+                  <TableHead className="h-12 px-3 text-sm">Status</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {rows.map((r) => (
+                  <TableRow key={r.priceAdjustmentId} className="cursor-pointer" onClick={() => open(r.priceAdjustmentId)}>
+                    <TableCell className="px-3 py-3 font-semibold">
+                      <Link href={`/dashboard/products/price-adjustments/${r.priceAdjustmentId}`} className="hover:underline">{r.docNo}</Link>
+                      <p className="text-xs font-normal text-muted-foreground">{new Date(r.createdAt).toLocaleString()}</p>
+                    </TableCell>
+                    <TableCell className="max-w-72 truncate px-3 py-3 text-sm text-muted-foreground">{r.reason}</TableCell>
+                    <TableCell className="px-3 py-3 text-right tabular-nums">{r.lineCount}</TableCell>
+                    <TableCell className="px-3 py-3 text-sm">{r.createdByName ?? `#${r.createdBy}`}</TableCell>
+                    <TableCell className="px-3 py-3"><PriceAdjustmentStatusBadge status={r.status} /></TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+          {pagination && (
+            <PaginationFooter pagination={pagination} onPageChange={setPage} pageSizeOptions={PAGE_SIZE_OPTIONS} onPageSizeChange={(s) => { setPage(1); setPageSize(s) }} />
+          )}
+        </>
+      )}
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/products/settings/page.tsx b/Frontend/erp-system/app/dashboard/products/settings/page.tsx
index f1323fc..47290ae 100644
--- a/Frontend/erp-system/app/dashboard/products/settings/page.tsx
+++ b/Frontend/erp-system/app/dashboard/products/settings/page.tsx
@@ -11,6 +11,7 @@ import { ProductConfig, UpdateProductConfigRequest } from "@/types/master-data"
 import { Skeleton } from "@/components/ui/skeleton"
 import { Switch } from "@/components/ui/switch"
 import { toast } from "@/components/ui/toast"
+import { invalidateTrackingSettings } from "@/hooks/use-tracking-settings"
 
 /**
  * Product Configuration (docs/11 §2.8; FR-MD-11) - the singleton feature gate.
@@ -61,6 +62,8 @@ export default function ProductSettingsPage() {
       )
       setConfig(res.data)
       setEtag(res.etag)
+      // Screens read the serial switch through a cached hook — make the next read fresh.
+      invalidateTrackingSettings()
       toast.success("Configuration saved", message)
       return true
     } catch (err) {
@@ -152,7 +155,7 @@ export default function ProductSettingsPage() {
 
             <ToggleRow
               label="Serial numbers"
-              description="Allows items to be created with Serial tracking."
+              description="On: serial-tracked items need one serial per unit on GRNs, sales, returns, transfers, adjustments and counts, and warranties follow each serial. Off: no serials are asked for or accepted anywhere; serial items are handled as plain stock (oldest first) and the Serials page is hidden. Existing serial history is kept."
               checked={config.serialNumbersEnabled}
               busy={saving === "serialNumbersEnabled"}
               onChange={(v) => toggle("serialNumbersEnabled", v)}
diff --git a/Frontend/erp-system/app/dashboard/receiving/grn/[id]/page.tsx b/Frontend/erp-system/app/dashboard/receiving/grn/[id]/page.tsx
index b7bd6a8..6fc438a 100644
--- a/Frontend/erp-system/app/dashboard/receiving/grn/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/receiving/grn/[id]/page.tsx
@@ -1,7 +1,7 @@
 "use client"
 
 import { useEffect, useRef, useState } from "react"
-import { useParams } from "next/navigation"
+import { useParams, useRouter } from "next/navigation"
 import Link from "next/link"
 import { BookOpen, CheckCircle2, FileText, PackageCheck, PackageX, Plus, ShieldAlert, XCircle } from "lucide-react"
 
@@ -13,9 +13,9 @@ import { purchaseInvoicesApi } from "@/lib/api/purchase-invoices"
 import { baseUomLabel } from "@/lib/uom-label"
 import { errorMessage } from "@/lib/error-map"
 import { cn } from "@/lib/utils"
-import { ConfirmGrnResponse, Grn } from "@/types/grn"
+import { ConfirmGrnResponse, Grn, GrnLine } from "@/types/grn"
 import { Bin, ItemListItem, Uom } from "@/types/master-data"
-import { PurchaseInvoice } from "@/types/purchase-invoices"
+import { PurchaseInvoice, PurchaseInvoicePayment, PurchaseInvoiceStatus } from "@/types/purchase-invoices"
 
 import { Badge } from "@/components/ui/badge"
 import { Button, buttonVariants } from "@/components/ui/button"
@@ -24,9 +24,40 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@
 import { toast } from "@/components/ui/toast"
 import { GrnStatusBadge, HoldStatusBadge } from "@/components/receiving/status-badges"
 import { PurchaseInvoiceStatusBadge } from "@/components/procurement/status-badges"
+import { PurchaseInvoicePrintDialog } from "@/components/procurement/PurchaseInvoicePrint"
+import { PurchaseInvoicePaymentDialog } from "@/components/procurement/PurchaseInvoicePaymentDialog"
+
+/** Batch (with expiry) and captured serial numbers of one GRN line — serials collapse behind a toggle. */
+function LineTrackingInfo({ line }: { line: GrnLine }) {
+  const serials = line.serials ?? []
+  if (!line.batchNo && serials.length === 0) return null
+  return (
+    <div className="mt-1 flex flex-col gap-1 text-xs text-muted-foreground">
+      {line.batchNo && (
+        <p>
+          Batch <span className="font-medium text-foreground">{line.batchNo}</span>
+          {line.batchExpiryDate && <> · expires {line.batchExpiryDate}</>}
+        </p>
+      )}
+      {serials.length > 0 && (
+        <details>
+          <summary className="cursor-pointer select-none">
+            {serials.length} serial number{serials.length === 1 ? "" : "s"}
+          </summary>
+          <ul className="mt-1 grid max-h-48 grid-cols-2 gap-x-4 overflow-y-auto font-mono">
+            {serials.map((s) => (
+              <li key={s.serialNo}>{s.serialNo}</li>
+            ))}
+          </ul>
+        </details>
+      )}
+    </div>
+  )
+}
 
 export default function GrnDetailPage() {
   const params = useParams<{ id: string }>()
+  const router = useRouter()
   const grnId = Number(params.id)
 
   const [grn, setGrn] = useState<Grn | null>(null)
@@ -40,6 +71,28 @@ export default function GrnDetailPage() {
   const [releasingLineId, setReleasingLineId] = useState<number | null>(null)
 
   const [linkedInvoice, setLinkedInvoice] = useState<PurchaseInvoice | null>(null)
+  const [viewInvoiceOpen, setViewInvoiceOpen] = useState(false)
+  const [payOpen, setPayOpen] = useState(false)
+  // Bumped after each payment so the invoice preview reloads with the new paid/balance.
+  const [invoiceRefreshKey, setInvoiceRefreshKey] = useState(0)
+
+  /** Keeps the "Balance due" line here, and the invoice preview, in step with payments recorded. */
+  function handleInvoicePaid(payment: PurchaseInvoicePayment, newStatus: PurchaseInvoiceStatus) {
+    setInvoiceRefreshKey((k) => k + 1)
+    setLinkedInvoice((prev) =>
+      prev
+        ? {
+            ...prev,
+            status: newStatus,
+            totals: {
+              ...prev.totals,
+              paidAmount: prev.totals.paidAmount + payment.amount,
+              balanceAmount: prev.totals.balanceAmount - payment.amount,
+            },
+          }
+        : prev
+    )
+  }
 
   // Stable per detail-page-session key so a retried confirm click doesn't double-post.
   const idempotencyKey = useRef(crypto.randomUUID())
@@ -210,6 +263,7 @@ export default function GrnDetailPage() {
                       {line.warrantyNumbers.length} warranty number{line.warrantyNumbers.length === 1 ? "" : "s"} captured
                     </p>
                   )}
+                  <LineTrackingInfo line={line} />
                 </div>
                 <HoldStatusBadge status={line.holdStatus} />
               </div>
@@ -332,6 +386,7 @@ export default function GrnDetailPage() {
                       {line.warrantyNumbers.length} warranty number{line.warrantyNumbers.length === 1 ? "" : "s"} captured
                     </p>
                   )}
+                  <LineTrackingInfo line={line} />
                 </TableCell>
                 <TableCell className="px-3 py-3.5">{baseUomLabel(items, uoms, line.itemId)}</TableCell>
                 <TableCell className="px-3 py-3.5">{binFor(line.binId)}</TableCell>
@@ -429,13 +484,10 @@ export default function GrnDetailPage() {
                   </span>
                 )}
               </div>
-              <Link
-                href={`/dashboard/procurement/purchase-invoices/${grn.purchaseInvoiceId}`}
-                className={cn(buttonVariants({ variant: "outline", size: "sm" }))}
-              >
+              <Button variant="outline" size="sm" onClick={() => setViewInvoiceOpen(true)}>
                 <FileText className="size-4" />
                 View invoice
-              </Link>
+              </Button>
             </div>
           ) : (
             <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
@@ -451,6 +503,28 @@ export default function GrnDetailPage() {
           )}
         </div>
       )}
+
+      <PurchaseInvoicePrintDialog
+        purchaseInvoiceId={grn.purchaseInvoiceId ?? null}
+        invoiceNo={linkedInvoice?.docNo}
+        open={viewInvoiceOpen}
+        onOpenChange={setViewInvoiceOpen}
+        refreshKey={invoiceRefreshKey}
+        actions={
+          linkedInvoice && linkedInvoice.status !== "Cancelled" ? (
+            <Button size="sm" onClick={() => setPayOpen(true)} disabled={linkedInvoice.totals.balanceAmount <= 0}>
+              {linkedInvoice.totals.balanceAmount <= 0 ? "Fully paid" : "Record payment"}
+            </Button>
+          ) : undefined
+        }
+      />
+      <PurchaseInvoicePaymentDialog
+        invoice={linkedInvoice}
+        open={payOpen}
+        onOpenChange={setPayOpen}
+        onPaid={handleInvoicePaid}
+        onFullyPaid={() => router.push("/dashboard/receiving/grn")}
+      />
     </div>
   )
 }
diff --git a/Frontend/erp-system/app/dashboard/receiving/grn/new/page.tsx b/Frontend/erp-system/app/dashboard/receiving/grn/new/page.tsx
index 21dcb10..724e46c 100644
--- a/Frontend/erp-system/app/dashboard/receiving/grn/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/receiving/grn/new/page.tsx
@@ -3,7 +3,7 @@
 import { useEffect, useMemo, useState } from "react"
 import { useRouter } from "next/navigation"
 import Link from "next/link"
-import { ArrowLeft, ExternalLink, RefreshCw, ShieldCheck, Trash2 } from "lucide-react"
+import { ArrowLeft, ExternalLink, RefreshCw, ShieldCheck, Trash2, Wand2 } from "lucide-react"
 
 import { ScanInput } from "@/components/scanning/ScanInput"
 import { ApiError } from "@/lib/api-client"
@@ -15,6 +15,8 @@ import { branchesHrmApi } from "@/lib/api/hrm-masters"
 import { itemsApi } from "@/lib/api/items"
 import { uomsApi } from "@/lib/api/uoms"
 import { grnConfigApi } from "@/lib/api/grn-config"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
+import { trackingApi } from "@/lib/api/tracking"
 import { baseUomLabel } from "@/lib/uom-label"
 import { errorMessage } from "@/lib/error-map"
 import { validateLine, grnHeaderSchema } from "@/lib/validations/grn"
@@ -40,12 +42,25 @@ import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip
 type Mode = "po" | "direct"
 type LineTab = "lines" | "warranty"
 
-/** Whole units a line's qty represents — one warranty number is captured per unit. */
+/** Whole units a line's qty represents — one warranty/serial number is captured per unit. */
 function unitCount(qty: string): number {
   const n = Math.floor(Number(qty))
   return Number.isFinite(n) && n > 0 ? n : 0
 }
 
+/**
+ * Items that need one number per received unit: serial-tracked items (their serial numbers —
+ * which double as the warranty identity, docs/ITEM_TRACKING_PLAN.md D1) and other warranty items.
+ */
+function capturesUnitNumbers(item: ItemListItem | null | undefined): boolean {
+  return item?.trackingMode === "Serial" || item?.warranty === "Warranty"
+}
+
+/** "serial number" for a serial-tracked item, else "warranty number". */
+function unitNumberLabel(item: ItemListItem | null | undefined): string {
+  return item?.trackingMode === "Serial" ? "serial number" : "warranty number"
+}
+
 /** One-shot hint next to the warranty button — shows on mount, then fades out on its own. */
 function WarrantyHintBubble() {
   const [visible, setVisible] = useState(true)
@@ -83,10 +98,15 @@ interface DraftLine {
   discountPct: string
   vatPct: string
   holdStatus: HoldStatus
-  /** One entry per received unit, index-aligned; only meaningful when the item is warranty-tracked. */
+  /**
+   * One entry per received unit, index-aligned; only meaningful when the item captures unit
+   * numbers — sent as `serialNumbers` for a serial-tracked item, else as `warrantyNumbers`.
+   */
   warrantyNumbers: string[]
-  /** Only meaningful when the item is batch-tracked; sent as `batch: { batchNo }` on submit. */
+  /** Only meaningful when the item is batch-tracked; sent as `batch: { batchNo, expiryDate }` on submit. */
   batchNo: string
+  /** yyyy-mm-dd, optional — drives FEFO picking and expiry blocking. */
+  batchExpiry: string
 }
 
 /** Mirror of the server's line arithmetic — display only (docs/20 §3, server stays authoritative). */
@@ -155,10 +175,12 @@ function buildWarrantyRange(from: string, to: string): string[] | null {
  * with a generated number — existing (manually edited) values are left untouched.
  */
 function syncWarrantyNumbers(l: DraftLine, item: ItemListItem | null): string[] {
-  if (item?.warranty !== "Warranty") return l.warrantyNumbers
+  if (!capturesUnitNumbers(item)) return l.warrantyNumbers
   const units = unitCount(l.qty)
   const next = l.warrantyNumbers.slice(0, units)
   while (next.length < units) next.push("")
+  // Serial numbers are the manufacturer's — never invent them; leave the slots for scanning.
+  if (item?.trackingMode === "Serial") return next
   for (let i = 0; i < units; i++) {
     if (!next[i] || next[i].trim() === "") next[i] = generateWarrantyNumber()
   }
@@ -179,12 +201,14 @@ function emptyLine(): DraftLine {
     holdStatus: "Available",
     warrantyNumbers: [],
     batchNo: "",
+    batchExpiry: "",
   }
 }
 
 export default function NewGrnPage() {
   const router = useRouter()
   const { isAdmin, branchId: myBranchId, activeBranchId, activeBranchName, branchingEnabled } = useAuth()
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   const [mode, setMode] = useState<Mode>("po")
 
@@ -339,6 +363,7 @@ export default function NewGrnPage() {
             holdStatus: "Available",
             warrantyNumbers: [],
             batchNo: "",
+            batchExpiry: "",
           }
           return { ...draft, warrantyNumbers: syncWarrantyNumbers(draft, itemFor(draft.itemId)) }
         })
@@ -440,8 +465,16 @@ export default function NewGrnPage() {
     setLines((prev) => prev.filter((l) => l.key !== key))
   }
 
+  /**
+   * The item as this GRN must treat it: with serial numbers switched off in Product
+   * Configuration a Serial item is received as untracked stock (a warranty item then takes
+   * warranty numbers again), so every serial rule below follows from this one place.
+   */
   function itemFor(itemId: number | null) {
-    return items?.find((i) => i.itemId === itemId) ?? null
+    const item = items?.find((i) => i.itemId === itemId) ?? null
+    return item && item.trackingMode === "Serial" && serialNumbersEnabled === false
+      ? { ...item, trackingMode: "None" as const }
+      : item
   }
 
   const itemOptions = useMemo<SuggestOption[]>(
@@ -530,11 +563,68 @@ export default function NewGrnPage() {
     // From/To are left exactly as typed — not cleared — so a typo is easy to fix in place.
   }
 
-  // Lines whose item is warranty-tracked and carry at least one unit — these are the rows
-  // the "Warranty numbers" tab needs to capture, one input per unit.
+  // Lines whose item is serial- or warranty-tracked and carry at least one unit — these are
+  // the rows the "Serial / warranty numbers" tab needs to capture, one input per unit.
   const warrantyLines = lines
     .map((l) => ({ line: l, item: itemFor(l.itemId), units: unitCount(l.qty) }))
-    .filter((w) => w.item?.warranty === "Warranty" && w.units > 0)
+    .filter((w) => capturesUnitNumbers(w.item) && w.units > 0)
+
+  // Bulk paste for a line's serial/warranty numbers — one per line (or comma-separated), filling
+  // units from the first; extra pasted values beyond the unit count are reported, not dropped silently.
+  const [pasteInputs, setPasteInputs] = useState<Record<string, string>>({})
+  function applyPastedNumbers(lineKey: string, units: number) {
+    const values = (pasteInputs[lineKey] ?? "").split(/[\r\n,;\t]+/).map((s) => s.trim()).filter((s) => s.length > 0)
+    if (values.length === 0) return
+    setLines((prev) =>
+      prev.map((l) => {
+        if (l.key !== lineKey) return l
+        const next = l.warrantyNumbers.slice(0, units)
+        while (next.length < units) next.push("")
+        values.slice(0, units).forEach((v, i) => (next[i] = v))
+        return { ...l, warrantyNumbers: next }
+      })
+    )
+    setPasteInputs((prev) => ({ ...prev, [lineKey]: "" }))
+    if (values.length > units)
+      toast.error("Too many numbers", `${values.length} pasted for ${units} unit(s) — the extra ${values.length - units} were not used.`)
+  }
+
+  // Auto-generate serial numbers: the server continues the highest number already used under the
+  // prefix (received + draft GRNs); numbers already typed on this form are skipped too. Only empty
+  // unit slots are filled — scanned/typed serials are never overwritten.
+  const [genPrefixes, setGenPrefixes] = useState<Record<string, string>>({})
+  const [generating, setGenerating] = useState<string | null>(null)
+  async function autoGenerateSerials(lineKey: string, itemId: number, units: number, prefix: string) {
+    const line = lines.find((l) => l.key === lineKey)
+    if (!line) return
+    const blanks = Array.from({ length: units }, (_, i) => i).filter((i) => !(line.warrantyNumbers[i] ?? "").trim())
+    if (blanks.length === 0) {
+      toast.error("Nothing to generate", "Every unit already has a serial number — clear some first.")
+      return
+    }
+    const inForm = new Set(
+      lines.filter((l) => l.itemId === itemId).flatMap((l) => l.warrantyNumbers.map((s) => s.trim().toLowerCase())).filter((s) => s)
+    )
+    setGenerating(lineKey)
+    try {
+      const fetched = await trackingApi.nextSerialNumbers(itemId, prefix, Math.min(1000, blanks.length + inForm.size))
+      const fresh = fetched.filter((n) => !inForm.has(n.toLowerCase())).slice(0, blanks.length)
+      setLines((prev) =>
+        prev.map((l) => {
+          if (l.key !== lineKey) return l
+          const next = l.warrantyNumbers.slice(0, units)
+          while (next.length < units) next.push("")
+          blanks.forEach((slot, i) => { if (fresh[i]) next[slot] = fresh[i] })
+          return { ...l, warrantyNumbers: next }
+        })
+      )
+      toast.success("Serial numbers generated", `${fresh.length} filled, starting ${fresh[0] ?? "—"}.`)
+    } catch (err) {
+      toast.error("Could not generate serial numbers", errorMessage(err))
+    } finally {
+      setGenerating(null)
+    }
+  }
 
   async function handleSubmit() {
     setSubmitError(null)
@@ -576,6 +666,8 @@ export default function NewGrnPage() {
         discountPct: allowDiscounts ? line.discountPct : "0",
         vatPct: allowVat ? line.vatPct : "0",
         warranty: item?.warranty ?? null,
+        trackingMode: item?.trackingMode ?? null,
+        batchNo: line.batchNo,
         warrantyNumbers: line.warrantyNumbers,
       })
       if (Object.keys(errors).length > 0) nextLineErrors[line.key] = errors
@@ -593,6 +685,8 @@ export default function NewGrnPage() {
 
     const payloadLines: CreateGrnLineInput[] = lines.map((l) => {
       const item = itemFor(l.itemId)
+      const unitNumbers = l.warrantyNumbers.map((s) => s.trim()).filter((s) => s.length > 0)
+      const serial = item?.trackingMode === "Serial"
       return {
         poLineId: l.poLineId,
         itemId: l.itemId as number,
@@ -602,11 +696,13 @@ export default function NewGrnPage() {
         discountPct: allowDiscounts ? Number(l.discountPct) || 0 : 0,
         vatPct: allowVat ? Number(l.vatPct) || 0 : 0,
         holdStatus: l.holdStatus,
-        warrantyNumbers:
-          item?.warranty === "Warranty"
-            ? l.warrantyNumbers.map((s) => s.trim()).filter((s) => s.length > 0)
+        // A serial item's serials are its warranty identity — it sends no warranty numbers.
+        serialNumbers: serial ? unitNumbers : null,
+        warrantyNumbers: !serial && item?.warranty === "Warranty" ? unitNumbers : null,
+        batch:
+          item?.trackingMode === "Batch" && l.batchNo.trim()
+            ? { batchNo: l.batchNo.trim(), expiryDate: l.batchExpiry || null }
             : null,
-        batch: item?.trackingMode === "Batch" && l.batchNo.trim() ? { batchNo: l.batchNo.trim() } : null,
       }
     })
 
@@ -861,7 +957,7 @@ export default function NewGrnPage() {
                 className="rounded-full"
                 onClick={() => setLineTab("warranty")}
               >
-                Warranty numbers
+                Serial / warranty numbers
                 {warrantyLines.length > 0 && (
                   <Badge variant="outline" className="ml-1.5 h-5 px-1.5 text-xs">
                     {warrantyLines.reduce((sum, w) => sum + w.units, 0)}
@@ -951,14 +1047,27 @@ export default function NewGrnPage() {
                         </div>
 
                         {item?.trackingMode === "Batch" && (
-                          <div>
-                            <Label className="text-sm">Batch no</Label>
-                            <Input
-                              value={line.batchNo}
-                              onChange={(e) => updateLine(line.key, { batchNo: e.target.value })}
-                              placeholder="Batch no"
-                              className="h-11 text-sm"
-                            />
+                          <div className="grid grid-cols-2 gap-3">
+                            <div>
+                              <Label className="text-sm">Batch no</Label>
+                              <Input
+                                value={line.batchNo}
+                                aria-invalid={!!errors.batchNo}
+                                onChange={(e) => updateLine(line.key, { batchNo: e.target.value })}
+                                placeholder="Batch no"
+                                className="h-11 text-sm"
+                              />
+                              <FieldError errors={[errors.batchNo ? { message: errors.batchNo } : undefined]} />
+                            </div>
+                            <div>
+                              <Label className="text-sm">Expiry</Label>
+                              <Input
+                                type="date"
+                                value={line.batchExpiry}
+                                onChange={(e) => updateLine(line.key, { batchExpiry: e.target.value })}
+                                className="h-11 text-sm"
+                              />
+                            </div>
                           </div>
                         )}
 
@@ -1050,10 +1159,10 @@ export default function NewGrnPage() {
                           </Select>
                         </div>
 
-                        {item?.warranty === "Warranty" && (
+                        {capturesUnitNumbers(item) && (
                           <Button type="button" variant="outline" size="sm" onClick={() => setLineTab("warranty")}>
                             <ShieldCheck className="size-4" />
-                            Add warranty numbers
+                            Add {unitNumberLabel(item)}s
                           </Button>
                         )}
                         {errors.warrantyNumbers && <FieldError errors={[{ message: errors.warrantyNumbers }]} />}
@@ -1134,12 +1243,24 @@ export default function NewGrnPage() {
                           </TableCell>
                           <TableCell className="px-3 py-3 align-top">
                             {item?.trackingMode === "Batch" ? (
-                              <Input
-                                value={line.batchNo}
-                                onChange={(e) => updateLine(line.key, { batchNo: e.target.value })}
-                                placeholder="Batch no"
-                                className="h-11 text-sm"
-                              />
+                              <div className="flex flex-col gap-1.5">
+                                <Input
+                                  value={line.batchNo}
+                                  aria-invalid={!!errors.batchNo}
+                                  onChange={(e) => updateLine(line.key, { batchNo: e.target.value })}
+                                  placeholder="Batch no"
+                                  className="h-11 text-sm"
+                                />
+                                <Input
+                                  type="date"
+                                  value={line.batchExpiry}
+                                  onChange={(e) => updateLine(line.key, { batchExpiry: e.target.value })}
+                                  aria-label="Batch expiry date"
+                                  title="Expiry date (optional)"
+                                  className="h-9 text-xs"
+                                />
+                                <FieldError errors={[errors.batchNo ? { message: errors.batchNo } : undefined]} />
+                              </div>
                             ) : (
                               <span className="text-sm text-muted-foreground">—</span>
                             )}
@@ -1237,7 +1358,7 @@ export default function NewGrnPage() {
                             </Select>
                           </TableCell>
                           <TableCell className="py-3 pr-0 pl-1 align-top">
-                            {item?.warranty === "Warranty" ? (
+                            {capturesUnitNumbers(item) ? (
                               <div className="relative flex flex-col gap-1">
                                 <Tooltip>
                                   <TooltipTrigger
@@ -1247,13 +1368,13 @@ export default function NewGrnPage() {
                                         variant="outline"
                                         size="icon"
                                         onClick={() => setLineTab("warranty")}
-                                        aria-label="Add warranty numbers"
+                                        aria-label={`Add ${unitNumberLabel(item)}s`}
                                       />
                                     }
                                   >
                                     <ShieldCheck className="size-4" />
                                   </TooltipTrigger>
-                                  <TooltipContent>Add warranty numbers</TooltipContent>
+                                  <TooltipContent>Add {unitNumberLabel(item)}s</TooltipContent>
                                 </Tooltip>
                                 {errors.warrantyNumbers && (
                                   <FieldError errors={[{ message: errors.warrantyNumbers }]} />
@@ -1311,8 +1432,8 @@ export default function NewGrnPage() {
 
                 {warrantyLines.length === 0 ? (
                   <p className="rounded-lg border border-dashed p-5 text-base text-muted-foreground">
-                    No warranty-tracked items on this GRN yet — add a line for an item marked
-                    “Warranty” to capture its numbers here.
+                    No serial- or warranty-tracked items on this GRN yet — add a line for such an
+                    item to capture one number per unit here.
                   </p>
                 ) : (
                   <div className="flex flex-col gap-6">
@@ -1320,11 +1441,65 @@ export default function NewGrnPage() {
                       const errors = lineErrors[line.key] ?? {}
                       const range = warrantyRangeInputs[line.key] ?? { from: "", adding: "" }
                       const addError = warrantyAddErrors[line.key]
+                      const serial = item?.trackingMode === "Serial"
+                      const label = unitNumberLabel(item)
+                      const entered = line.warrantyNumbers.filter((s) => s.trim().length > 0).length
                       return (
                         <div key={line.key} className="flex flex-col gap-2">
-                          <div className="text-sm font-semibold text-foreground">
+                          <div className="flex flex-wrap items-center gap-2 text-sm font-semibold text-foreground">
                             {item ? `${item.sku} — ${item.name}` : `Item #${line.itemId}`}
+                            <Badge variant="outline" className="text-xs">{serial ? "Serial" : "Warranty"}</Badge>
+                            {serial && item?.warranty === "Warranty" && (
+                              <Badge variant="outline" className="text-xs">Warranty starts at sale</Badge>
+                            )}
+                            <span className={cn("text-xs font-normal", entered === units ? "text-success" : "text-muted-foreground")}>
+                              {entered} of {units} entered
+                            </span>
                           </div>
+                          {serial && (
+                            <div className="flex flex-wrap items-end gap-2 rounded-lg border border-dashed border-input p-3">
+                              <div className="flex min-w-64 flex-1 flex-col gap-1">
+                                <Label className="text-xs text-muted-foreground">Paste or scan serial numbers</Label>
+                                <textarea
+                                  value={pasteInputs[line.key] ?? ""}
+                                  onChange={(e) => setPasteInputs((prev) => ({ ...prev, [line.key]: e.target.value }))}
+                                  placeholder="One per line (or comma-separated)"
+                                  rows={3}
+                                  className="w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm"
+                                />
+                              </div>
+                              <Button type="button" variant="outline" size="sm" onClick={() => applyPastedNumbers(line.key, units)}>
+                                Fill units
+                              </Button>
+                            </div>
+                          )}
+                          {serial && line.itemId && (
+                            <div className="flex flex-wrap items-end gap-2 rounded-lg border border-dashed border-input p-3">
+                              <div className="flex flex-col gap-1">
+                                <Label className="text-xs text-muted-foreground">Prefix</Label>
+                                <Input
+                                  value={genPrefixes[line.key] ?? `${item?.sku ?? "SN"}-`}
+                                  onChange={(e) => setGenPrefixes((prev) => ({ ...prev, [line.key]: e.target.value }))}
+                                  placeholder="e.g. PH-"
+                                  className="h-9 w-44 text-sm"
+                                />
+                              </div>
+                              <Button
+                                type="button"
+                                variant="outline"
+                                size="sm"
+                                disabled={generating === line.key}
+                                onClick={() => autoGenerateSerials(line.key, line.itemId as number, units, genPrefixes[line.key] ?? `${item?.sku ?? "SN"}-`)}
+                              >
+                                <Wand2 className="size-4" />
+                                {generating === line.key ? "Generating…" : "Auto-generate"}
+                              </Button>
+                              <span className="text-xs text-muted-foreground">
+                                For units without a manufacturer serial — fills only the empty units with the next
+                                free numbers (e.g. {`${genPrefixes[line.key] ?? `${item?.sku ?? "SN"}-`}0001`}).
+                              </span>
+                            </div>
+                          )}
                           <div className="flex flex-wrap items-end gap-2 rounded-lg border border-dashed border-input p-3">
                             <div className="flex flex-col gap-1">
                               <Label className="text-xs text-muted-foreground">From</Label>
@@ -1365,8 +1540,10 @@ export default function NewGrnPage() {
                                 <TableRow>
                                   <TableHead className="h-10 w-20 px-3 text-sm">Unit</TableHead>
                                   <TableHead className="h-10 px-3 text-sm">
-                                    Warranty number
-                                    <span className="ml-1.5 font-normal text-muted-foreground">(auto-generated — edit if needed)</span>
+                                    {serial ? "Serial number" : "Warranty number"}
+                                    <span className="ml-1.5 font-normal text-muted-foreground">
+                                      {serial ? "(scan or type the unit's serial)" : "(auto-generated — edit if needed)"}
+                                    </span>
                                   </TableHead>
                                 </TableRow>
                               </TableHeader>
@@ -1381,7 +1558,8 @@ export default function NewGrnPage() {
                                         value={line.warrantyNumbers[i] ?? ""}
                                         aria-invalid={!!errors.warrantyNumbers}
                                         onChange={(e) => setWarrantyNumberAt(line.key, i, e.target.value)}
-                                        placeholder="e.g. WTY-000123"
+                                        placeholder={serial ? "e.g. SN-48213" : "e.g. WTY-000123"}
+                                        aria-label={`${label} for unit ${i + 1}`}
                                         className="h-10 max-w-xs text-sm"
                                       />
                                       {i === units - 1 && (
diff --git a/Frontend/erp-system/app/dashboard/sales/day-end-report/page.tsx b/Frontend/erp-system/app/dashboard/sales/day-end-report/page.tsx
new file mode 100644
index 0000000..6f665a0
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/sales/day-end-report/page.tsx
@@ -0,0 +1,576 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import Link from "next/link"
+import {
+  ArrowLeft,
+  Banknote,
+  CreditCard,
+  FileDown,
+  Hash,
+  Landmark,
+  PiggyBank,
+  Receipt,
+  ReceiptText,
+  TrendingDown,
+  TrendingUp,
+  Wallet,
+} from "lucide-react"
+
+import { dayEndReportApi } from "@/lib/api/day-end-report"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount, formatReportDate, formatSignedAmount, profitOrLoss } from "@/lib/format"
+import { downloadDailyIncomePdf, downloadDayEndReportPdf } from "@/lib/pdf/day-end-report-pdf"
+import { cn } from "@/lib/utils"
+import { maskAccountNumber } from "@/types/bank-deposits"
+import { DayEndDailyReport, DayEndReport, DayEndReportDay, DayEndReportDeposit } from "@/types/sales"
+
+import { useAuth } from "@/components/auth/AuthProvider"
+import { DayEndIncomeChart } from "@/components/sales/DayEndIncomeChart"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { Skeleton } from "@/components/ui/skeleton"
+import { StatCard } from "@/components/ui/stat-card"
+import { Table, TableBody, TableCell, TableFooter, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { toast } from "@/components/ui/toast"
+
+const MAX_RANGE_DAYS = 92
+
+/** Local yyyy-MM-dd, `offsetDays` from today. */
+function localIso(offsetDays = 0): string {
+  const d = new Date()
+  d.setDate(d.getDate() + offsetDays)
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
+}
+
+function daysBetween(from: string, to: string): number {
+  return Math.round((Date.parse(to) - Date.parse(from)) / 86_400_000) + 1
+}
+
+type Loaded<T> = { key: string; data: T | null; error: string | null }
+
+/** Income with a minus sign when negative, plus a red "Loss" tag so it reads as a loss. */
+function IncomeCell({ value, bold = false }: { value: number; bold?: boolean }) {
+  return (
+    <TableCell className={cn("text-right tabular-nums whitespace-nowrap", bold ? "font-semibold" : "font-medium", value < 0 && "text-destructive")}>
+      {value < 0 && <span className="mr-1.5 text-xs font-medium">Loss</span>}
+      {formatSignedAmount(value)}
+    </TableCell>
+  )
+}
+
+/** "Profit 1,200.00" / "Loss 300.00" (red) — a loss is labelled, not just shown negative. */
+function ProfitCell({ value, bold = false }: { value: number; bold?: boolean }) {
+  const p = profitOrLoss(value)
+  return (
+    <TableCell className={cn("text-right tabular-nums whitespace-nowrap", bold && "font-semibold", p.isLoss && "text-destructive")}>
+      <span className="mr-1.5 text-xs font-medium">{p.label}</span>
+      {p.amount}
+    </TableCell>
+  )
+}
+
+/** The day's result as a short statement: sales − cost = gross profit − expenses = net profit or loss. */
+function ProfitStatement({ day }: { day: DayEndReportDay }) {
+  const gross = profitOrLoss(day.grossProfit)
+  const net = profitOrLoss(day.netProfit)
+  const Icon = net.isLoss ? TrendingDown : TrendingUp
+  return (
+    <div className="flex flex-col gap-2">
+      <h2 className="text-sm font-semibold text-foreground">Profit / loss</h2>
+      <div className="ml-auto grid w-full max-w-md grid-cols-[1fr_auto] gap-x-6 gap-y-1.5 rounded-xl border border-border p-4 text-sm">
+        <span className="text-muted-foreground">Total sales</span>
+        <span className="text-right tabular-nums">{formatAmount(day.totalSales)}</span>
+        <span className="text-muted-foreground">Less: cost of goods sold</span>
+        <span className="text-right tabular-nums">({formatAmount(day.costOfGoodsSold)})</span>
+        <span className="border-t border-border pt-1.5 font-medium">Gross {gross.label.toLowerCase()}</span>
+        <span className={cn("border-t border-border pt-1.5 text-right font-medium tabular-nums", gross.isLoss && "text-destructive")}>
+          {gross.amount}
+        </span>
+        <span className="text-muted-foreground">Less: expenses</span>
+        <span className="text-right tabular-nums">({formatAmount(day.expenseTotal)})</span>
+        <div
+          className={cn(
+            "col-span-2 mt-1.5 flex items-center justify-between rounded-lg px-3 py-2.5",
+            net.isLoss ? "bg-destructive/10 text-destructive" : "bg-success/10 text-success"
+          )}
+        >
+          <span className="flex items-center gap-2 text-base font-semibold">
+            <Icon className="size-4" aria-hidden />
+            Net {net.label.toLowerCase()}
+          </span>
+          <span className="text-xl font-bold tabular-nums">{net.amount}</span>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+/**
+ * Till cash for the day (docs/BANK_DEPOSIT_MODULE_PLAN.md §9): what was carried in, what the day added, what was
+ * banked, and what is still in hand — plus the deposits themselves. The figures come from the Bank Deposit module.
+ */
+function CashInHandSection({ day, deposits, date }: { day: DayEndReportDay; deposits: DayEndReportDeposit[]; date: string }) {
+  const remaining = day.closingCashInHand ?? 0
+  return (
+    <div className="flex flex-col gap-2">
+      <div className="flex items-center justify-between gap-3">
+        <h2 className="text-sm font-semibold text-foreground">Cash in hand</h2>
+        <Link href="/dashboard/accounts/bank-deposits/new" className="text-sm font-medium text-primary hover:underline">
+          Record a bank deposit
+        </Link>
+      </div>
+      <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
+        <StatCard label="Opening cash in hand" value={formatAmount(day.openingCashInHand ?? 0)} icon={Wallet} />
+        <StatCard label="Net cash today" value={formatAmount(day.netCash)} icon={Banknote} />
+        <StatCard label="Deposited to bank" value={formatAmount(day.cashDeposited ?? 0)} icon={Landmark} />
+        <div
+          className={cn(
+            "flex flex-col gap-1.5 rounded-xl p-3.5 shadow-sm ring-1",
+            remaining > 0 ? "bg-warning/10 ring-warning/30" : "bg-card ring-border"
+          )}
+        >
+          <div className="flex items-start justify-between gap-2">
+            <p className="text-sm font-semibold text-foreground">Remaining cash in hand</p>
+            <PiggyBank className={cn("size-4", remaining > 0 ? "text-warning" : "text-muted-foreground")} aria-hidden />
+          </div>
+          <p className={cn("text-xl font-bold tracking-tight tabular-nums", remaining > 0 ? "text-warning" : "text-foreground")}>
+            {formatAmount(remaining)}
+          </p>
+          <p className="text-xs text-muted-foreground">{remaining > 0 ? "Not yet deposited" : "All cash banked"}</p>
+        </div>
+      </div>
+      <p className="text-xs text-muted-foreground">
+        Net cash = cash sales + cash collected on invoices − expenses paid in cash. Only cash is deposited; card and transfers go
+        straight to the bank.
+      </p>
+
+      {deposits.length === 0 ? (
+        <p className="text-sm text-muted-foreground">No bank deposits for {formatReportDate(date)}.</p>
+      ) : (
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Deposit</TableHead>
+              <TableHead>Bank account</TableHead>
+              <TableHead>Slip no.</TableHead>
+              <TableHead>Deposited on</TableHead>
+              <TableHead className="text-right">Amount</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {deposits.map((d) => (
+              <TableRow key={d.bankDepositId}>
+                <TableCell>
+                  <Link href={`/dashboard/accounts/bank-deposits/${d.bankDepositId}`} className="text-primary hover:underline">{d.docNo}</Link>
+                </TableCell>
+                <TableCell>
+                  {d.bankAccountName}
+                  {(d.bankName || d.accountNumber) && (
+                    <span className="text-muted-foreground"> · {[d.bankName, maskAccountNumber(d.accountNumber)].filter(Boolean).join(" · ")}</span>
+                  )}
+                </TableCell>
+                <TableCell>{d.depositSlipNo ?? "—"}</TableCell>
+                <TableCell>{formatReportDate(d.depositDate)}</TableCell>
+                <TableCell className="text-right tabular-nums">{formatAmount(d.amount)}</TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+          <TableFooter>
+            <TableRow>
+              <TableCell colSpan={4} className="font-semibold">Total deposited</TableCell>
+              <TableCell className="text-right font-semibold tabular-nums">{formatAmount(day.cashDeposited ?? 0)}</TableCell>
+            </TableRow>
+          </TableFooter>
+        </Table>
+      )}
+    </div>
+  )
+}
+
+export default function DayEndReportPage() {
+  const { isAdmin, activeBranchId, activeBranchName, branchName, branchingEnabled } = useAuth()
+  // Admins follow the header's branch switcher (null = all branches); everyone else is scoped to
+  // their own branch server-side, whatever is sent.
+  const branchId = isAdmin ? activeBranchId : null
+  const branchLabel = !branchingEnabled ? "All" : isAdmin ? (activeBranchName ?? "All branches") : (branchName ?? "-")
+
+  const [date, setDate] = useState(localIso())
+  const [from, setFrom] = useState(localIso(-29))
+  const [to, setTo] = useState(localIso())
+  const [downloading, setDownloading] = useState<"day" | "range" | null>(null)
+
+  const rangeDays = from && to ? daysBetween(from, to) : 0
+  const rangeError = !from || !to
+    ? "Pick both dates"
+    : rangeDays < 1
+      ? "'To' must be on or after 'From'"
+      : rangeDays > MAX_RANGE_DAYS
+        ? `Pick at most ${MAX_RANGE_DAYS} days`
+        : null
+
+  // Results are tagged with the request they answer; a stale or pending one reads as "loading".
+  const dayKey = `${date}|${branchId}`
+  const [dayResult, setDayResult] = useState<Loaded<DayEndReport> | null>(null)
+  const day = dayResult?.key === dayKey ? dayResult : null
+
+  const rangeKey = `${from}|${to}|${branchId}`
+  const [rangeResult, setRangeResult] = useState<Loaded<DayEndDailyReport> | null>(null)
+  const range = rangeResult?.key === rangeKey ? rangeResult : null
+
+  useEffect(() => {
+    if (!date) return
+    let cancelled = false
+    dayEndReportApi
+      .getDay({ date, branchId })
+      .then((data) => !cancelled && setDayResult({ key: dayKey, data, error: null }))
+      .catch((err) => !cancelled && setDayResult({ key: dayKey, data: null, error: errorMessage(err) }))
+    return () => {
+      cancelled = true
+    }
+  }, [date, branchId, dayKey])
+
+  useEffect(() => {
+    if (rangeError) return
+    let cancelled = false
+    dayEndReportApi
+      .getDaily({ from, to, branchId })
+      .then((data) => !cancelled && setRangeResult({ key: rangeKey, data, error: null }))
+      .catch((err) => !cancelled && setRangeResult({ key: rangeKey, data: null, error: errorMessage(err) }))
+    return () => {
+      cancelled = true
+    }
+  }, [from, to, branchId, rangeKey, rangeError])
+
+  async function downloadDay() {
+    if (!day?.data) return
+    setDownloading("day")
+    try {
+      await downloadDayEndReportPdf(day.data, branchLabel)
+    } catch (err) {
+      toast.error("Could not create the PDF", errorMessage(err))
+    } finally {
+      setDownloading(null)
+    }
+  }
+
+  async function downloadRange() {
+    if (!range?.data) return
+    setDownloading("range")
+    try {
+      await downloadDailyIncomePdf(range.data, branchLabel)
+    } catch (err) {
+      toast.error("Could not create the PDF", errorMessage(err))
+    } finally {
+      setDownloading(null)
+    }
+  }
+
+  const s = day?.data?.summary
+  // `?? []` keeps the page up against a backend that predates these lists.
+  const sales = day?.data?.sales ?? []
+  const expenses = day?.data?.expenses ?? []
+  const deposits = day?.data?.deposits ?? []
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="flex items-center gap-3">
+        <Link href="/dashboard/sales" className={cn(buttonVariants({ variant: "outline", size: "icon" }))}>
+          <ArrowLeft className="size-4" />
+        </Link>
+        <div>
+          <h1 className="text-2xl font-bold text-foreground">Day-End Report</h1>
+          <p className="text-base text-muted-foreground">
+            A day&apos;s sales, how they were paid, its expenses and the resulting income — plus income day by day.
+            {branchingEnabled && <> Branch: <span className="font-medium text-foreground">{branchLabel}</span>.</>}
+          </p>
+        </div>
+      </div>
+
+      {/* --- One day ------------------------------------------------------------------------- */}
+      <section className="flex flex-col gap-4 rounded-2xl border border-border bg-card p-5 shadow-[var(--shadow-panel)]">
+        <div className="flex flex-col gap-3 sm:flex-row sm:items-end sm:justify-between">
+          <div className="flex flex-col gap-2">
+            <Label htmlFor="der-date" className="text-base">Business date</Label>
+            <Input id="der-date" type="date" value={date} max={localIso()} onChange={(e) => setDate(e.target.value)} className="h-11 w-48 text-base" />
+          </div>
+          <Button variant="outline" onClick={downloadDay} disabled={!day?.data || downloading !== null}>
+            <FileDown className="size-4" />
+            {downloading === "day" ? "Creating PDF…" : "Download day PDF"}
+          </Button>
+        </div>
+
+        {day?.error && <p className="text-sm text-destructive">{day.error}</p>}
+
+        {!s && !day?.error && (
+          <div className="grid grid-cols-2 gap-3 sm:grid-cols-5">
+            {Array.from({ length: 10 }).map((_, i) => <Skeleton key={i} className="h-[84px] rounded-xl" />)}
+          </div>
+        )}
+
+        {s && (
+          <>
+            <div className="flex flex-col gap-2">
+              <h2 className="text-sm font-semibold text-foreground">Sales</h2>
+              <div className="grid grid-cols-2 gap-3 sm:grid-cols-5">
+                <StatCard label="Total sales" value={formatAmount(s.totalSales)} icon={ReceiptText} />
+                <StatCard label="Paid amount" value={formatAmount(s.paidAmount)} icon={Wallet} />
+                <StatCard label="Due amount" value={formatAmount(s.dueAmount)} icon={Receipt} />
+                <StatCard label="Paid by cash" value={formatAmount(s.paidByCash)} icon={Banknote} />
+                <StatCard label="Paid by card" value={formatAmount(s.paidByCard)} icon={CreditCard} />
+              </div>
+              <div className="grid grid-cols-2 gap-3 sm:grid-cols-5">
+                <StatCard label="Sales count" value={String(s.salesCount)} icon={Hash} />
+                <StatCard label="Cash sales" value={String(s.cashSalesCount)} icon={Banknote} />
+                <StatCard label="Card sales" value={String(s.cardSalesCount)} icon={CreditCard} />
+                <StatCard label="Expenses" value={formatAmount(s.expenseTotal)} icon={Receipt} />
+                <div
+                  className={cn(
+                    "flex flex-col gap-1.5 rounded-xl p-3.5 shadow-sm ring-1",
+                    s.income >= 0 ? "bg-success/10 ring-success/30" : "bg-destructive/10 ring-destructive/30"
+                  )}
+                >
+                  <div className="flex items-start justify-between gap-2">
+                    <p className="text-sm font-semibold text-foreground">Income</p>
+                    {s.income >= 0
+                      ? <TrendingUp className="size-4 text-success" aria-hidden />
+                      : <TrendingDown className="size-4 text-destructive" aria-hidden />}
+                  </div>
+                  <p className={cn("text-xl font-bold tracking-tight tabular-nums", s.income >= 0 ? "text-success" : "text-destructive")}>
+                    {formatSignedAmount(s.income)}
+                  </p>
+                  {s.income < 0 ? (
+                    <p className="text-xs font-semibold text-destructive">Loss — expenses are more than sales</p>
+                  ) : (
+                    <p className="text-xs text-muted-foreground">Sales − expenses</p>
+                  )}
+                </div>
+              </div>
+              <p className="text-sm text-muted-foreground">
+                {s.mixedSalesCount} paid partly cash, partly card · {s.otherSalesCount} by bank transfer/cheque
+                ({formatAmount(s.paidByOther)}) · {s.unpaidSalesCount} not paid yet · Collected on earlier invoices:{" "}
+                <span className="font-medium text-foreground tabular-nums">{formatAmount(s.earlierInvoiceCollections)}</span>
+              </p>
+            </div>
+
+            <CashInHandSection day={s} deposits={deposits} date={date} />
+
+            <div className="flex flex-col gap-2">
+              <h2 className="text-sm font-semibold text-foreground">Sales of the day ({sales.length})</h2>
+              {sales.length === 0 ? (
+                <p className="text-sm text-muted-foreground">No posted sales on {formatReportDate(date)}.</p>
+              ) : (
+                <div className="max-h-[28rem] overflow-auto rounded-lg border border-border">
+                  <Table>
+                    <TableHeader className="sticky top-0 bg-card">
+                      <TableRow>
+                        <TableHead>Time</TableHead>
+                        <TableHead>No.</TableHead>
+                        <TableHead>Type</TableHead>
+                        <TableHead>Customer</TableHead>
+                        <TableHead>Paid by</TableHead>
+                        <TableHead className="text-right">Total</TableHead>
+                        <TableHead className="text-right">Paid</TableHead>
+                        <TableHead className="text-right">Due</TableHead>
+                        <TableHead className="text-right">Cost</TableHead>
+                        <TableHead className="text-right">Profit</TableHead>
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                      {sales.map((row) => (
+                        <TableRow key={`${row.docType}-${row.docId}`}>
+                          <TableCell className="tabular-nums">
+                            {new Date(row.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
+                          </TableCell>
+                          <TableCell>
+                            {row.docType === "Invoice" ? (
+                              <Link href={`/dashboard/sales/invoices/${row.docId}`} className="text-primary hover:underline">{row.docNo}</Link>
+                            ) : (
+                              row.docNo
+                            )}
+                          </TableCell>
+                          <TableCell>{row.docType}</TableCell>
+                          <TableCell>{row.customerName}</TableCell>
+                          <TableCell>{row.paidBy}</TableCell>
+                          <TableCell className="text-right tabular-nums">{formatAmount(row.total)}</TableCell>
+                          <TableCell className="text-right tabular-nums">{formatAmount(row.paid)}</TableCell>
+                          <TableCell className="text-right tabular-nums">{formatAmount(row.due, true)}</TableCell>
+                          <TableCell className="text-right tabular-nums">{formatAmount(row.cost)}</TableCell>
+                          <TableCell className={cn("text-right tabular-nums", row.grossProfit < 0 && "text-destructive")}>
+                            {formatAmount(row.grossProfit)}
+                          </TableCell>
+                        </TableRow>
+                      ))}
+                    </TableBody>
+                    <TableFooter>
+                      <TableRow>
+                        <TableCell colSpan={5} className="font-semibold">Total</TableCell>
+                        <TableCell className="text-right font-semibold tabular-nums">{formatAmount(s.totalSales)}</TableCell>
+                        <TableCell className="text-right font-semibold tabular-nums">{formatAmount(s.paidAmount)}</TableCell>
+                        <TableCell className="text-right font-semibold tabular-nums">{formatAmount(s.dueAmount)}</TableCell>
+                        <TableCell className="text-right font-semibold tabular-nums">{formatAmount(s.costOfGoodsSold)}</TableCell>
+                        <TableCell className="text-right font-semibold tabular-nums">{formatAmount(s.grossProfit)}</TableCell>
+                      </TableRow>
+                    </TableFooter>
+                  </Table>
+                </div>
+              )}
+            </div>
+
+            <div className="flex flex-col gap-2">
+              <h2 className="text-sm font-semibold text-foreground">Expenses of the day</h2>
+              {expenses.length === 0 ? (
+                <p className="text-sm text-muted-foreground">No posted expenses on {formatReportDate(date)}.</p>
+              ) : (
+                <Table>
+                  <TableHeader>
+                    <TableRow>
+                      <TableHead>Doc no.</TableHead>
+                      <TableHead>Category</TableHead>
+                      <TableHead>Title</TableHead>
+                      <TableHead>Payee</TableHead>
+                      <TableHead className="text-right">Amount</TableHead>
+                      <TableHead className="text-right">Paid</TableHead>
+                    </TableRow>
+                  </TableHeader>
+                  <TableBody>
+                    {expenses.map((e) => (
+                      <TableRow key={e.expenseId}>
+                        <TableCell>
+                          <Link href={`/dashboard/accounts/expenses/${e.expenseId}`} className="text-primary hover:underline">{e.docNo}</Link>
+                        </TableCell>
+                        <TableCell>{e.categoryName}</TableCell>
+                        <TableCell>{e.titleName}</TableCell>
+                        <TableCell>{e.payee ?? "—"}</TableCell>
+                        <TableCell className="text-right tabular-nums">{formatAmount(e.amount)}</TableCell>
+                        <TableCell className="text-right tabular-nums">{formatAmount(e.paidAmount)}</TableCell>
+                      </TableRow>
+                    ))}
+                  </TableBody>
+                  <TableFooter>
+                    <TableRow>
+                      <TableCell colSpan={4} className="font-semibold">Total</TableCell>
+                      <TableCell className="text-right font-semibold tabular-nums">{formatAmount(s.expenseTotal)}</TableCell>
+                      <TableCell />
+                    </TableRow>
+                  </TableFooter>
+                </Table>
+              )}
+            </div>
+
+            <ProfitStatement day={s} />
+          </>
+        )}
+      </section>
+
+      {/* --- Day-wise income ----------------------------------------------------------------- */}
+      <section className="flex flex-col gap-4 rounded-2xl border border-border bg-card p-5 shadow-[var(--shadow-panel)]">
+        <div className="flex flex-col gap-3 sm:flex-row sm:items-end sm:justify-between">
+          <div>
+            <h2 className="text-lg font-semibold text-foreground">Day-wise income</h2>
+            <p className="text-sm text-muted-foreground">Income = sales − expenses, per day (up to {MAX_RANGE_DAYS} days).</p>
+          </div>
+          <div className="flex flex-wrap items-end gap-3">
+            <div className="flex flex-col gap-1.5">
+              <Label htmlFor="der-from">From</Label>
+              <Input id="der-from" type="date" value={from} max={to || localIso()} onChange={(e) => setFrom(e.target.value)} className="w-44" />
+            </div>
+            <div className="flex flex-col gap-1.5">
+              <Label htmlFor="der-to">To</Label>
+              <Input id="der-to" type="date" value={to} min={from} max={localIso()} onChange={(e) => setTo(e.target.value)} className="w-44" />
+            </div>
+            <Button onClick={downloadRange} disabled={!range?.data || downloading !== null}>
+              <FileDown className="size-4" />
+              {downloading === "range" ? "Creating PDF…" : "Download PDF"}
+            </Button>
+          </div>
+        </div>
+
+        {rangeError && <p className="text-sm text-destructive">{rangeError}</p>}
+        {!rangeError && range?.error && <p className="text-sm text-destructive">{range.error}</p>}
+        {!rangeError && !range && <Skeleton className="h-72 rounded-xl" />}
+
+        {!rangeError && range?.data && (
+          <>
+            <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
+              <StatCard label="Sales" value={formatAmount(range.data.totals.totalSales)} icon={ReceiptText} />
+              <StatCard label="Expenses" value={formatAmount(range.data.totals.expenseTotal)} icon={Receipt} />
+              <StatCard
+                label={range.data.totals.income < 0 ? "Income (loss)" : "Income"}
+                value={formatSignedAmount(range.data.totals.income)}
+                icon={range.data.totals.income >= 0 ? TrendingUp : TrendingDown}
+                className={range.data.totals.income < 0 ? "bg-destructive/10 ring-destructive/30" : undefined}
+              />
+              <StatCard
+                label={`Net ${profitOrLoss(range.data.totals.netProfit).label.toLowerCase()}`}
+                value={profitOrLoss(range.data.totals.netProfit).amount}
+                icon={range.data.totals.netProfit >= 0 ? TrendingUp : TrendingDown}
+                className={range.data.totals.netProfit < 0 ? "bg-destructive/10 ring-destructive/30" : "bg-success/10 ring-success/30"}
+              />
+            </div>
+
+            <DayEndIncomeChart days={range.data.days} />
+
+            <div className="max-h-[28rem] overflow-auto rounded-lg border border-border">
+              <Table>
+                <TableHeader className="sticky top-0 bg-card">
+                  <TableRow>
+                    <TableHead>Date</TableHead>
+                    <TableHead className="text-right">Sales</TableHead>
+                    <TableHead className="text-right">Paid</TableHead>
+                    <TableHead className="text-right">Due</TableHead>
+                    <TableHead className="text-right">Cash</TableHead>
+                    <TableHead className="text-right">Card</TableHead>
+                    <TableHead className="text-right">Count</TableHead>
+                    <TableHead className="text-right">Expenses</TableHead>
+                    <TableHead className="text-right">Income</TableHead>
+                    <TableHead className="text-right">Profit / loss</TableHead>
+                    <TableHead className="text-right">Deposited</TableHead>
+                    <TableHead className="text-right">Cash in hand</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {[...range.data.days].reverse().map((d) => (
+                    <TableRow key={d.date} className="cursor-pointer" onClick={() => d.date && setDate(d.date)} title="Show this day above">
+                      <TableCell>{formatReportDate(d.date)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.totalSales)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.paidAmount)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.dueAmount)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.paidByCash)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.paidByCard)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{d.salesCount}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.expenseTotal)}</TableCell>
+                      <IncomeCell value={d.income} />
+                      <ProfitCell value={d.netProfit} />
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.cashDeposited ?? 0, true)}</TableCell>
+                      <TableCell className="text-right tabular-nums">{formatAmount(d.closingCashInHand ?? 0)}</TableCell>
+                    </TableRow>
+                  ))}
+                </TableBody>
+                <TableFooter>
+                  <TableRow>
+                    <TableCell className="font-semibold">Total</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.totalSales)}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.paidAmount)}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.dueAmount)}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.paidByCash)}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.paidByCard)}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{range.data.totals.salesCount}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.expenseTotal)}</TableCell>
+                    <IncomeCell value={range.data.totals.income} bold />
+                    <ProfitCell value={range.data.totals.netProfit} bold />
+                    <TableCell className="text-right font-semibold tabular-nums">{formatAmount(range.data.totals.cashDeposited ?? 0)}</TableCell>
+                    <TableCell className="text-right font-semibold tabular-nums" title="Cash in hand at the end of the last day">
+                      {formatAmount(range.data.totals.closingCashInHand ?? 0)}
+                    </TableCell>
+                  </TableRow>
+                </TableFooter>
+              </Table>
+            </div>
+          </>
+        )}
+      </section>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/sales/free-issues/new/page.tsx b/Frontend/erp-system/app/dashboard/sales/free-issues/new/page.tsx
index 2b7f2e9..f026a2b 100644
--- a/Frontend/erp-system/app/dashboard/sales/free-issues/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/sales/free-issues/new/page.tsx
@@ -7,6 +7,8 @@ import { ArrowLeft, Pencil, Plus, Save, Trash2 } from "lucide-react"
 import { Button, buttonVariants } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
 import { SuggestInput } from "@/components/ui/suggest-input"
+import { trackingTags } from "@/lib/tracking-tags"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 import {
   Dialog,
   DialogContent,
@@ -74,6 +76,7 @@ const blankLine = (key: string): Line => ({
 export default function NewFreeIssuePage() {
   const [customers, setCustomers] = useState<Customer[]>([])
   const [items, setItems] = useState<ItemListItem[]>([])
+  const { serialNumbersEnabled } = useTrackingSettings()
   const [uoms, setUoms] = useState<Uom[]>([])
   const [warehouses, setWarehouses] = useState<Warehouse[]>([])
   const [users, setUsers] = useState<ManagedUser[]>([])
@@ -162,8 +165,8 @@ export default function NewFreeIssuePage() {
   }
 
   const itemOptions = useMemo(
-    () => items.map((i) => ({ value: String(i.itemId), label: `${i.sku} — ${i.name}` })),
-    [items]
+    () => items.map((i) => ({ value: String(i.itemId), label: `${i.sku} — ${i.name}`, tags: trackingTags(i.trackingMode, serialNumbersEnabled) })),
+    [items, serialNumbersEnabled]
   )
 
   function selectItem(key: string, itemId: number) {
diff --git a/Frontend/erp-system/app/dashboard/sales/invoices/[id]/page.tsx b/Frontend/erp-system/app/dashboard/sales/invoices/[id]/page.tsx
index 76293e0..3a20a9e 100644
--- a/Frontend/erp-system/app/dashboard/sales/invoices/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/sales/invoices/[id]/page.tsx
@@ -22,10 +22,14 @@ import { ItemListItem, Uom, Warehouse } from "@/types/master-data"
 import { CompanyProfile } from "@/types/company-profile"
 import { InvoiceTemplateConfig } from "@/types/invoice-template"
 import { CreateSalesInvoiceLineRequest, SalesInvoice, SalesInvoicePayment, SalesInvoicePostingCheck, SalesInvoiceStatus, SalesInvoiceType } from "@/types/sales"
+import { SalesLineSerial } from "@/types/tracking"
+import { LineTrackingPicker } from "@/components/sales/LineTrackingPicker"
 import { toast } from "@/components/ui/toast"
 import { Label } from "@/components/ui/label"
 import { Button } from "@/components/ui/button"
 import { SuggestInput } from "@/components/ui/suggest-input"
+import { trackingTags } from "@/lib/tracking-tags"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 import { SalesInvoicePaymentDialog } from "@/components/sales/SalesInvoicePaymentDialog"
 import { SalesInvoicePrintDialog } from "@/components/sales/SalesInvoicePrint"
 import { SalesInvoiceStatusBadge, SalesPaymentStatusBadge } from "@/components/sales/status-badges"
@@ -33,7 +37,8 @@ import { InvoicePrintHeader } from "@/components/invoice-template/InvoicePrintHe
 import { InvoicePrintFooter } from "@/components/invoice-template/InvoicePrintFooter"
 import { getInvoiceLayoutClasses } from "@/components/invoice-template/invoiceLayoutPresets"
 
-type Line = CreateSalesInvoiceLineRequest & { key: string }
+// batchNo/serials are display state for the tracking picker; batchId + serial ids are what saves.
+type Line = CreateSalesInvoiceLineRequest & { key: string; batchNo?: string | null; serials?: SalesLineSerial[] }
 
 const money = new Intl.NumberFormat("en-LK", {
   style: "currency",
@@ -70,6 +75,8 @@ function draftSnapshot(customerId: number | null, warehouseId: number | null, in
       qty: Number(line.qty),
       freeQty: Number(line.freeQty),
       unitPrice: line.unitPrice ?? null,
+      batchId: line.batchId ?? null,
+      serialIds: (line.serials ?? []).map((s) => s.serialId),
     })),
   })
 }
@@ -88,6 +95,7 @@ export default function SalesInvoiceDetailPage({ params }: { params: Promise<{ i
   const [printOpen, setPrintOpen] = useState(false)
   const [customers, setCustomers] = useState<Customer[]>([])
   const [items, setItems] = useState<ItemListItem[]>([])
+  const { serialNumbersEnabled } = useTrackingSettings()
   const [uoms, setUoms] = useState<Uom[]>([])
   const [warehouses, setWarehouses] = useState<Warehouse[]>([])
   const [company, setCompany] = useState<CompanyProfile | null>(null)
@@ -165,6 +173,9 @@ export default function SalesInvoiceDetailPage({ params }: { params: Promise<{ i
           taxPct: line.taxPct,
           isFreeIssue: line.isFreeIssue,
           parentLineId: line.parentLineId,
+          batchId: line.batchId ?? null,
+          batchNo: null,
+          serials: line.serials ?? [],
         }))
         setLines(loadedLines)
         setSavedSnapshot(draftSnapshot(doc.data.customerId, doc.data.warehouseId, doc.data.invoiceType, loadedLines))
@@ -242,9 +253,14 @@ export default function SalesInvoiceDetailPage({ params }: { params: Promise<{ i
     () =>
       items.map((i) => {
         const price = getSuggestedUnitPrice(items, i.itemId)
-        return { value: String(i.itemId), label: `${i.sku} — ${i.name}`, hint: price !== null ? money.format(price) : undefined }
+        return {
+          value: String(i.itemId),
+          label: `${i.sku} — ${i.name}`,
+          hint: price !== null ? money.format(price) : undefined,
+          tags: trackingTags(i.trackingMode, serialNumbersEnabled),
+        }
       }),
-    [items],
+    [items, serialNumbersEnabled],
   )
 
   function itemLabel(itemId: number) {
@@ -309,6 +325,8 @@ export default function SalesInvoiceDetailPage({ params }: { params: Promise<{ i
             taxPct: Number(line.taxPct),
             isFreeIssue: allowFreeItems && line.isFreeIssue,
             parentLineId: line.parentLineId || null,
+            batchId: line.batchId ?? null,
+            serialIds: line.serials && line.serials.length > 0 ? line.serials.map((s) => s.serialId) : null,
           })),
         },
         etag,
@@ -534,6 +552,14 @@ export default function SalesInvoiceDetailPage({ params }: { params: Promise<{ i
                     <tr key={line.key} className="border-t border-border align-middle">
                       <td className="min-w-64 px-4 py-3">
                         <span className="font-medium text-foreground">{itemLabel(line.itemId)}</span>
+                        <LineTrackingPicker
+                          itemId={line.itemId}
+                          warehouseId={line.warehouseId || warehouseId}
+                          trackingMode={items.find((i) => i.itemId === line.itemId)?.trackingMode}
+                          units={Number(line.qty || 0) + (allowFreeItems ? Number(line.freeQty || 0) : 0)}
+                          value={{ batchId: line.batchId ?? null, batchNo: line.batchNo ?? null, serials: line.serials ?? [] }}
+                          onChange={(v) => updateLine(line.key, { batchId: v.batchId, batchNo: v.batchNo, serials: v.serials })}
+                        />
                       </td>
                       <td className="min-w-32 px-4 py-3 text-sm text-muted-foreground">{baseUomLabel(items, uoms, line.itemId)}</td>
                       <td className="w-28 px-4 py-3">
@@ -611,6 +637,11 @@ export default function SalesInvoiceDetailPage({ params }: { params: Promise<{ i
                   <td className="px-4 py-3">
                     <div className="font-medium text-foreground">{line.description}</div>
                     <div className="text-xs text-muted-foreground">SKU {items.find((i) => i.itemId === line.itemId)?.sku ?? `#${line.itemId}`}</div>
+                    {(line.serials ?? []).length > 0 && (
+                      <div className="mt-0.5 font-mono text-xs text-muted-foreground">
+                        S/N {(line.serials ?? []).map((s) => s.serialNo).join(", ")}
+                      </div>
+                    )}
                   </td>
                   <td className="px-4 py-3">{baseUomLabel(items, uoms, line.itemId)}</td>
                   <td className="px-4 py-3 text-right">{line.qty.toFixed(0)}</td>
diff --git a/Frontend/erp-system/app/dashboard/sales/invoices/new/page.tsx b/Frontend/erp-system/app/dashboard/sales/invoices/new/page.tsx
index 4723e4a..241156f 100644
--- a/Frontend/erp-system/app/dashboard/sales/invoices/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/sales/invoices/new/page.tsx
@@ -13,6 +13,7 @@ import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
 import { SuggestBadgeTone, SuggestInput } from "@/components/ui/suggest-input"
+import { trackingTags } from "@/lib/tracking-tags"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { Skeleton } from "@/components/ui/skeleton"
 import { cn } from "@/lib/utils"
@@ -40,6 +41,9 @@ import {
   SalesStockAvailability,
 } from "@/types/sales"
 import { BundleSaleTemplateSummary } from "@/types/bundles"
+import { SalesLineSerial } from "@/types/tracking"
+import { LineTrackingPicker } from "@/components/sales/LineTrackingPicker"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 import { toast } from "@/components/ui/toast"
 
 // bundleGroupId/bundleName/bundleQty/bundleBaseQty are frontend-only display metadata (never sent
@@ -47,11 +51,10 @@ import { toast } from "@/components/ui/toast"
 // component lines added from the same bundle render collapsed into one row, with a single "how
 // many bundles" quantity that scales every component's qty (bundleBaseQty holds the per-bundle
 // qty from the template so re-scaling on a qty change is exact, not compounding).
-// batchId/serialId/batchNo/serialNo are frontend-only display metadata from a barcode/RFID scan
-// (see ScanInput below) — the live CreateSalesInvoiceLineRequest DTO has no batch/serial fields
-// yet (only CreateSalesSlipLineRequest does), so these are carried for display/traceability on
-// this draft line but deliberately NOT sent in submit()'s payload until the invoice line request
-// grows the same fields.
+// batchId/serials are sent (docs/ITEM_TRACKING_PLAN.md Phase 4): a batch item may pin a batch (else
+// posting picks FEFO), a serial item must carry one serial per unit of qty + free qty. They are
+// filled by a barcode/RFID scan (ScanInput below) or the per-line LineTrackingPicker.
+// batchNo/serialId/serialNo are display metadata from the scan.
 type Line = CreateSalesInvoiceLineRequest & {
   key: string
   bundleGroupId?: string
@@ -62,6 +65,7 @@ type Line = CreateSalesInvoiceLineRequest & {
   batchNo?: string | null
   serialId?: number | null
   serialNo?: string | null
+  serials?: SalesLineSerial[]
 }
 
 type DisplayRow =
@@ -103,6 +107,7 @@ const blankLine = (key: string): Line => ({
   batchNo: null,
   serialId: null,
   serialNo: null,
+  serials: [],
 })
 
 const lkr = new Intl.NumberFormat("en-LK", {
@@ -120,6 +125,7 @@ function NewSalesInvoiceContent() {
   const appliedBundleRef = useRef<string | null>(null)
   const bundleGroupSeqRef = useRef(0)
   const { isAdmin, branchId: myBranchId, activeBranchId, activeBranchName, branchingEnabled } = useAuth()
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   const [customers, setCustomers] = useState<Customer[]>([])
   const [items, setItems] = useState<ItemListItem[]>([])
@@ -295,8 +301,7 @@ function NewSalesInvoiceContent() {
 
   // Fast path for a barcode/RFID scan above the lines table: resolves the code to an item (and
   // optionally its batch/serial), then either bumps an existing line for the same item+lot by one
-  // unit, or appends a new line for it — batchId/serialId ride along on the line for traceability
-  // (see the Line type note above re: submit() not yet sending them).
+  // unit, or appends a new line for it — a scanned serial becomes that line's chosen serial.
   // Shared by the "Add item" suggestion box and barcode scans: bumps an existing line for the
   // same item+lot by one unit, or appends a new line for it. Returns the affected line's key.
   function addItem(
@@ -331,6 +336,7 @@ function NewSalesInvoiceContent() {
           batchNo: lot.batchNo ?? null,
           serialId: lot.serialId ?? null,
           serialNo: lot.serialNo ?? null,
+          serials: lot.serialId ? [{ serialId: lot.serialId, serialNo: lot.serialNo ?? String(lot.serialId) }] : [],
         },
       ]
     })
@@ -517,9 +523,10 @@ function NewSalesInvoiceContent() {
         const stocked = i.stockNature === "Stocked"
         const qty = stockByItem ? (stockByItem.get(i.itemId) ?? 0) : null
         const uom = uoms.find((u) => u.uomId === i.baseUomId)?.name
+        // Tracking shows as a highlighted tag (Serial / Batch) instead of detail text.
+        const tags = trackingTags(i.trackingMode, serialNumbersEnabled)
         const detail = [
           uom,
-          i.trackingMode !== "None" ? `${i.trackingMode} tracked` : null,
           i.warranty === "Warranty" && i.warrantyPeriodMonths ? `${i.warrantyPeriodMonths}m warranty` : null,
           i.taxRateName ? `Tax: ${i.taxRateName}` : null,
         ]
@@ -530,11 +537,12 @@ function NewSalesInvoiceContent() {
           label: `${i.sku} — ${i.name}`,
           hint: price !== null ? lkr.format(price) : undefined,
           detail: detail || undefined,
+          tags,
           badge: !stocked ? "Non-stock" : qty === null ? "Stock: —" : `Stock: ${qtyFormat.format(qty)}`,
           badgeTone: (!stocked || qty === null ? "muted" : qty > 0 ? "success" : "danger") as SuggestBadgeTone,
         }
       }),
-    [items, uoms, stockByItem],
+    [items, uoms, stockByItem, serialNumbersEnabled],
   )
 
   const bundleTemplateOptions = useMemo(
@@ -617,6 +625,29 @@ function NewSalesInvoiceContent() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [loading, bundleTemplateIdFromQuery])
 
+  /** Units a serial line still needs serials for (0 for any other item). */
+  function serialsShort(line: Line): number {
+    const item = items.find((i) => i.itemId === line.itemId)
+    if (item?.trackingMode !== "Serial" || serialNumbersEnabled === false) return 0
+    const units = Number(line.qty || 0) + (allowFreeItems ? Number(line.freeQty || 0) : 0)
+    return Math.max(0, units - (line.serials?.length ?? 0))
+  }
+
+  /** Batch / serial picker under a line's item name (nothing for untracked items). */
+  function renderTracking(line: Line) {
+    const item = items.find((i) => i.itemId === line.itemId)
+    return (
+      <LineTrackingPicker
+        itemId={line.itemId}
+        warehouseId={line.warehouseId || warehouseId}
+        trackingMode={item?.trackingMode}
+        units={Number(line.qty || 0) + (allowFreeItems ? Number(line.freeQty || 0) : 0)}
+        value={{ batchId: line.batchId ?? null, batchNo: line.batchNo ?? null, serials: line.serials ?? [] }}
+        onChange={(v) => updateLine(line.key, { batchId: v.batchId, batchNo: v.batchNo, serials: v.serials })}
+      />
+    )
+  }
+
   function itemLabel(itemId: number) {
     const item = items.find((i) => i.itemId === itemId)
     return item ? `${item.sku} — ${item.name}` : `Item #${itemId}`
@@ -693,6 +724,11 @@ function NewSalesInvoiceContent() {
       const detail = [...new Set(short.map((l) => `${itemLabel(l.itemId)} (${stockShortage(l)} available)`))].join(", ")
       return setSubmitError(`Quantity exceeds available stock: ${detail}. Reduce the quantity to continue.`)
     }
+    const missingSerials = lines.filter((line) => serialsShort(line) > 0)
+    if (missingSerials.length > 0) {
+      const detail = missingSerials.map((l) => `${itemLabel(l.itemId)} (${serialsShort(l)} more)`).join(", ")
+      return setSubmitError(`Select a serial number for every unit: ${detail}.`)
+    }
 
     const payload: CreateSalesInvoiceRequest = {
       customerId,
@@ -713,6 +749,8 @@ function NewSalesInvoiceContent() {
         taxPct: Number(line.taxPct),
         isFreeIssue: allowFreeItems && line.isFreeIssue,
         parentLineId: line.parentLineId || null,
+        batchId: line.batchId ?? null,
+        serialIds: line.serials && line.serials.length > 0 ? line.serials.map((s) => s.serialId) : null,
       })),
     }
 
@@ -954,9 +992,7 @@ function NewSalesInvoiceContent() {
                       <div className="flex-1">
                         <Label className="text-sm">Item {idx + 1}</Label>
                         <p className="py-1 text-sm font-medium text-foreground">{itemLabel(line.itemId)}</p>
-                        {(line.batchNo || line.serialNo) && (
-                          <p className="mt-1 text-xs text-muted-foreground">Lot: {line.batchNo ?? line.serialNo}</p>
-                        )}
+                        {renderTracking(line)}
                       </div>
                       <Button
                         type="button"
@@ -1150,11 +1186,7 @@ function NewSalesInvoiceContent() {
                         <TableCell className="px-3 py-3 align-top text-sm">{idx + 1}</TableCell>
                         <TableCell className="px-3 py-3 align-top">
                           <div className="flex min-h-11 items-center text-sm font-medium text-foreground">{itemLabel(line.itemId)}</div>
-                          {(line.batchNo || line.serialNo) && (
-                            <p className="mt-1 text-xs text-muted-foreground">
-                              Lot: {line.batchNo ?? line.serialNo}
-                            </p>
-                          )}
+                          {renderTracking(line)}
                         </TableCell>
                         <TableCell className="px-3 py-3 align-top">
                           <div className="flex h-11 items-center text-sm text-muted-foreground">
diff --git a/Frontend/erp-system/app/dashboard/sales/warranties/page.tsx b/Frontend/erp-system/app/dashboard/sales/warranties/page.tsx
new file mode 100644
index 0000000..51798f0
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/sales/warranties/page.tsx
@@ -0,0 +1,147 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { ShieldCheck } from "lucide-react"
+
+import { trackingApi } from "@/lib/api/tracking"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { PagedResponse } from "@/types/common"
+import { WarrantyRegistration } from "@/types/tracking"
+
+import { Badge } from "@/components/ui/badge"
+import { Input } from "@/components/ui/input"
+import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+
+type View = "active" | "expiring" | "expired" | "voided" | "all"
+
+const VIEWS: { value: View; label: string }[] = [
+  { value: "active", label: "Active" },
+  { value: "expiring", label: "Expiring within 30 days" },
+  { value: "expired", label: "Expired" },
+  { value: "voided", label: "Voided (returned)" },
+  { value: "all", label: "All" },
+]
+
+const DOC_LABEL: Record<string, string> = { SI: "Invoice", SSL: "Slip", BND: "Bundle" }
+
+/**
+ * Customer warranty register (docs/ITEM_TRACKING_PLAN.md Phase 5). A warranty starts when the
+ * sale is posted — never at goods receipt — and is voided if the unit comes back on a return.
+ */
+export default function WarrantiesPage() {
+  const [view, setView] = useState<View>("active")
+  const [q, setQ] = useState("")
+  const [page, setPage] = useState(1)
+  const [data, setData] = useState<PagedResponse<WarrantyRegistration> | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    const filters =
+      view === "active" ? { status: "Active" as const, expired: false }
+      : view === "expiring" ? { expiringWithinDays: 30 }
+      : view === "expired" ? { status: "Active" as const, expired: true }
+      : view === "voided" ? { status: "Voided" as const }
+      : {}
+    const timer = setTimeout(() => {
+      trackingApi
+        .listWarranties({ ...filters, q: q.trim() || undefined, page, pageSize: 25 })
+        .then((r) => { if (!cancelled) { setData(r); setError(null) } })
+        .catch((err) => { if (!cancelled) setError(errorMessage(err)) })
+    }, 250)
+    return () => { cancelled = true; clearTimeout(timer) }
+  }, [view, q, page])
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Warranties</h1>
+        <p className="text-base text-muted-foreground">
+          Customer warranties start on the day the sale is posted. Scan a serial to check its cover.
+        </p>
+      </div>
+
+      <div className="flex flex-wrap items-end gap-3">
+        <Input
+          value={q}
+          onChange={(e) => { setPage(1); setQ(e.target.value) }}
+          placeholder="Scan serial, or search SKU / item…"
+          className="h-11 min-w-64 flex-1 text-base"
+        />
+        <Select<View> value={view} onValueChange={(v) => { setPage(1); if (v) setView(v) }}>
+          <SelectTrigger className="h-11! w-60 text-sm">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent>
+            {VIEWS.map((v) => (
+              <SelectItem key={v.value} value={v.value} className="text-sm">{v.label}</SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!data && !error && <Skeleton className="h-40 w-full" />}
+
+      {data && data.items.length === 0 && (
+        <div className="flex flex-col items-center gap-3 rounded-xl border border-dashed py-16 text-center">
+          <ShieldCheck className="size-10 text-muted-foreground" />
+          <p className="text-base text-muted-foreground">No warranties in this view.</p>
+        </div>
+      )}
+
+      {data && data.items.length > 0 && (
+        <div className="overflow-x-auto">
+          <Table className="text-sm">
+            <TableHeader>
+              <TableRow>
+                <TableHead className="px-3">Item / serial</TableHead>
+                <TableHead className="px-3">Customer</TableHead>
+                <TableHead className="px-3">Sold on</TableHead>
+                <TableHead className="px-3">Cover</TableHead>
+                <TableHead className="px-3">Ends</TableHead>
+                <TableHead className="px-3">Status</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {data.items.map((w) => (
+                <TableRow key={w.warrantyRegistrationId}>
+                  <TableCell className="px-3 py-3">
+                    <div className="font-medium">{w.sku} — {w.itemName}</div>
+                    <div className="font-mono text-xs text-muted-foreground">{w.serialNo ?? `${w.qty} unit${w.qty === 1 ? "" : "s"} (no serial)`}</div>
+                  </TableCell>
+                  <TableCell className="px-3 py-3">{w.customerName}</TableCell>
+                  <TableCell className="px-3 py-3">
+                    {w.startDate}
+                    <div className="text-xs text-muted-foreground">{DOC_LABEL[w.sourceDocType] ?? w.sourceDocType} #{w.sourceDocId}</div>
+                  </TableCell>
+                  <TableCell className="px-3 py-3">{w.periodMonths} months</TableCell>
+                  <TableCell className="px-3 py-3">{w.endDate}</TableCell>
+                  <TableCell className="px-3 py-3">
+                    <Badge
+                      variant="outline"
+                      className={cn(
+                        "text-xs",
+                        w.status !== "Active" ? "text-muted-foreground"
+                          : w.isExpired ? "border-destructive/40 text-destructive"
+                          : w.daysRemaining <= 30 ? "border-warning/50 text-warning"
+                          : "border-success/40 text-success"
+                      )}
+                    >
+                      {w.status !== "Active" ? w.status : w.isExpired ? "Expired" : `${w.daysRemaining} days left`}
+                    </Badge>
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+          <PaginationFooter pagination={data.pagination} onPageChange={setPage} />
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/settings/approvals/page.tsx b/Frontend/erp-system/app/dashboard/settings/approvals/page.tsx
new file mode 100644
index 0000000..6e2c2b0
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/settings/approvals/page.tsx
@@ -0,0 +1,144 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { Save } from "lucide-react"
+
+import { approvalsApi } from "@/lib/api/approvals"
+import { errorMessage } from "@/lib/error-map"
+import { ApprovalConfig } from "@/types/approvals"
+
+import { Button } from "@/components/ui/button"
+import { Field, FieldDescription, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { toast } from "@/components/ui/toast"
+
+const levelOptions = [
+  { value: "2", label: "Two approvals — two different people" },
+  { value: "1", label: "One approval" },
+  { value: "0", label: "No approval — applies immediately" },
+]
+
+/** Settings → Approvals (docs/DUAL_APPROVAL_PLAN.md §7): how many approvals stock and price adjustments need. */
+export default function ApprovalSettingsPage() {
+  const [config, setConfig] = useState<ApprovalConfig | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [stockLevels, setStockLevels] = useState("2")
+  const [stockThreshold, setStockThreshold] = useState("0")
+  const [priceLevels, setPriceLevels] = useState("2")
+  const [priceThreshold, setPriceThreshold] = useState("0")
+  const [roles, setRoles] = useState("")
+  const [saving, setSaving] = useState(false)
+
+  function apply(c: ApprovalConfig) {
+    setConfig(c)
+    setStockLevels(String(c.stockAdjustmentLevels))
+    setStockThreshold(String(c.stockAdjustmentLevel2ThresholdValue))
+    setPriceLevels(String(c.priceAdjustmentLevels))
+    setPriceThreshold(String(c.priceAdjustmentLevel2ThresholdPercent))
+    setRoles(c.level2RoleCodes.join(", "))
+  }
+
+  useEffect(() => {
+    approvalsApi.getConfig().then(apply).catch((err) => setError(errorMessage(err)))
+  }, [])
+
+  async function save() {
+    const sv = Number(stockThreshold)
+    const pv = Number(priceThreshold)
+    if (Number.isNaN(sv) || sv < 0 || Number.isNaN(pv) || pv < 0) {
+      toast.error("Check the thresholds", "Thresholds must be 0 or more.")
+      return
+    }
+    setSaving(true)
+    try {
+      const saved = await approvalsApi.updateConfig({
+        stockAdjustmentLevels: Number(stockLevels),
+        stockAdjustmentLevel2ThresholdValue: sv,
+        priceAdjustmentLevels: Number(priceLevels),
+        priceAdjustmentLevel2ThresholdPercent: pv,
+        level2RoleCodes: roles.split(",").map((r) => r.trim()).filter(Boolean),
+      })
+      apply(saved)
+      toast.success("Approval settings saved", "They apply to requests made from now on.")
+    } catch (err) {
+      toast.error("Could not save approval settings", errorMessage(err))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  if (error) return <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+  if (!config) return <Skeleton className="h-96 w-full" />
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Approvals</h1>
+        <p className="text-base text-muted-foreground">
+          How many people must approve a stock or price adjustment before it takes effect. The requester can never approve their own request,
+          and with two approvals the second must be a different person from the first. Changes apply to new requests; pending ones keep their rule.
+        </p>
+      </div>
+
+      <div className="grid grid-cols-1 gap-4 lg:grid-cols-2">
+        <section className="flex flex-col gap-4 rounded-2xl border bg-card p-5 shadow-sm">
+          <h2 className="text-lg font-semibold text-foreground">Stock adjustments</h2>
+          <p className="text-sm text-muted-foreground">Adjustments, wastage and stock-count variances.</p>
+          <Field>
+            <FieldLabel>Approvals required</FieldLabel>
+            <Select<string> value={stockLevels} onValueChange={(v) => v && setStockLevels(v)}>
+              <SelectTrigger className="h-11! w-full text-base"><SelectValue /></SelectTrigger>
+              <SelectContent>{levelOptions.map((o) => <SelectItem key={o.value} value={o.value} className="text-base">{o.label}</SelectItem>)}</SelectContent>
+            </Select>
+          </Field>
+          {stockLevels === "2" && (
+            <Field>
+              <FieldLabel htmlFor="stock-threshold">Second approval only from value (LKR)</FieldLabel>
+              <Input id="stock-threshold" type="number" min="0" step="0.01" value={stockThreshold} onChange={(e) => setStockThreshold(e.target.value)} className="h-11 text-base" />
+              <FieldDescription>Adjustments worth less than this (at FIFO cost) need only one approval. 0 = always two.</FieldDescription>
+            </Field>
+          )}
+        </section>
+
+        <section className="flex flex-col gap-4 rounded-2xl border bg-card p-5 shadow-sm">
+          <h2 className="text-lg font-semibold text-foreground">Price adjustments</h2>
+          <p className="text-sm text-muted-foreground">Selling-price changes. While this is not “No approval”, prices can’t be edited directly on an item.</p>
+          <Field>
+            <FieldLabel>Approvals required</FieldLabel>
+            <Select<string> value={priceLevels} onValueChange={(v) => v && setPriceLevels(v)}>
+              <SelectTrigger className="h-11! w-full text-base"><SelectValue /></SelectTrigger>
+              <SelectContent>{levelOptions.map((o) => <SelectItem key={o.value} value={o.value} className="text-base">{o.label}</SelectItem>)}</SelectContent>
+            </Select>
+          </Field>
+          {priceLevels === "2" && (
+            <Field>
+              <FieldLabel htmlFor="price-threshold">Second approval only from change of (%)</FieldLabel>
+              <Input id="price-threshold" type="number" min="0" step="0.1" value={priceThreshold} onChange={(e) => setPriceThreshold(e.target.value)} className="h-11 text-base" />
+              <FieldDescription>Changes smaller than this need only one approval. Setting or clearing a price counts as 100%. 0 = always two.</FieldDescription>
+            </Field>
+          )}
+        </section>
+      </div>
+
+      <section className="flex flex-col gap-4 rounded-2xl border bg-card p-5 shadow-sm">
+        <Field>
+          <FieldLabel htmlFor="level2-roles">Who can give the second approval (role codes)</FieldLabel>
+          <Input id="level2-roles" value={roles} onChange={(e) => setRoles(e.target.value)} placeholder="e.g. Manager, Accountant — leave empty for anyone with the Approve permission" className="h-11 text-base" />
+          <FieldDescription>
+            Comma-separated. Anyone giving an approval also needs the Approve permission on the screen (Settings → Roles).
+            Make sure at least two people per branch can approve, or requests will wait forever.
+          </FieldDescription>
+        </Field>
+      </section>
+
+      <div className="flex justify-end">
+        <Button size="lg" onClick={save} disabled={saving}>
+          <Save className="size-5" />
+          {saving ? "Saving…" : "Save settings"}
+        </Button>
+      </div>
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/stock/adjustments/[id]/page.tsx b/Frontend/erp-system/app/dashboard/stock/adjustments/[id]/page.tsx
new file mode 100644
index 0000000..4c60656
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/stock/adjustments/[id]/page.tsx
@@ -0,0 +1,157 @@
+"use client"
+
+import { use, useCallback, useEffect, useState } from "react"
+import Link from "next/link"
+import { ArrowLeft } from "lucide-react"
+
+import { itemsApi } from "@/lib/api/items"
+import { reasonCodesApi } from "@/lib/api/reason-codes"
+import { stockAdjustmentsApi } from "@/lib/api/stock-adjustments"
+import { warehousesApi } from "@/lib/api/warehouses"
+import { errorMessage } from "@/lib/error-map"
+import { StockAdjustment } from "@/types/stock"
+
+import { ApprovalPanel } from "@/components/approvals/ApprovalPanel"
+import { AdjustmentStatusBadge } from "@/components/stock/status-badges"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { toast } from "@/components/ui/toast"
+
+/** One stock adjustment: its lines, its approval trail, and Approve / Reject / Withdraw (docs/DUAL_APPROVAL_PLAN.md §10). */
+export default function AdjustmentDetailPage({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = use(params)
+  const adjustmentId = Number(id)
+
+  const [adjustment, setAdjustment] = useState<StockAdjustment | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const error = Number.isFinite(adjustmentId) ? loadError : `Invalid adjustment id '${id}'.`
+  const [itemLabels, setItemLabels] = useState<Map<number, string>>(new Map())
+  const [warehouse, setWarehouse] = useState<string | null>(null)
+  const [reason, setReason] = useState<string | null>(null)
+
+  const load = useCallback(() => {
+    if (!Number.isFinite(adjustmentId)) return
+    stockAdjustmentsApi.get(adjustmentId).then(setAdjustment).catch((err) => setLoadError(errorMessage(err)))
+  }, [adjustmentId])
+
+  useEffect(load, [load])
+
+  useEffect(() => {
+    if (!adjustment) return
+    itemsApi.list({ pageSize: 200 }).then((r) => setItemLabels(new Map(r.items.map((i) => [i.itemId, `${i.sku} — ${i.name}`])))).catch(() => {})
+    warehousesApi.list().then((r) => setWarehouse(r.items.find((w) => w.warehouseId === adjustment.warehouseId)?.code ?? null)).catch(() => {})
+    reasonCodesApi.list("Adjustment").then((r) => setReason(r.items.find((c) => c.reasonCodeId === adjustment.reasonCodeId)?.description ?? null)).catch(() => {})
+  }, [adjustment])
+
+  if (error) {
+    return (
+      <div className="flex flex-col gap-4">
+        <BackLink />
+        <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+      </div>
+    )
+  }
+  if (!adjustment) return <Skeleton className="h-96 w-full" />
+
+  const a = adjustment
+  const outcome = a.status === "Posted" ? "applied" : a.status === "Rejected" ? "rejected" : a.status === "Cancelled" ? "withdrawn" : "pending"
+
+  return (
+    <div className="flex flex-col gap-6">
+      <BackLink />
+      <div className="flex flex-col gap-2">
+        <div className="flex flex-wrap items-center gap-3">
+          <h1 className="text-2xl font-bold text-foreground">{a.docNo}</h1>
+          <AdjustmentStatusBadge status={a.status} />
+        </div>
+        <p className="text-base text-muted-foreground">
+          {warehouse ?? `Warehouse #${a.warehouseId}`} · {reason ?? `Reason #${a.reasonCodeId}`}
+          {a.glJournalNo ? ` · Journal ${a.glJournalNo}` : ""}
+        </p>
+        {outcome === "pending" && (
+          <p className="text-sm text-warning">This is a request — stock has not moved and nothing is posted until it is fully approved.</p>
+        )}
+      </div>
+
+      <div className="grid grid-cols-1 gap-6 lg:grid-cols-[1fr_24rem]">
+        <div className="overflow-x-auto rounded-xl border">
+          <Table className="text-base">
+            <TableHeader>
+              <TableRow>
+                <TableHead className="h-11 px-4 text-sm">Item</TableHead>
+                <TableHead className="h-11 px-4 text-right text-sm">Qty change</TableHead>
+                <TableHead className="h-11 px-4 text-sm">Serials</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {a.lines.map((l) => (
+                <TableRow key={l.adjLineId}>
+                  <TableCell className="px-4 py-3">{itemLabels.get(l.itemId) ?? `Item #${l.itemId}`}</TableCell>
+                  <TableCell className={`px-4 py-3 text-right font-semibold tabular-nums ${l.qtyDelta < 0 ? "text-destructive" : "text-success"}`}>
+                    {l.qtyDelta > 0 ? `+${l.qtyDelta}` : l.qtyDelta}
+                  </TableCell>
+                  <TableCell className="px-4 py-3 text-sm text-muted-foreground">
+                    {[...(l.requestedSerialNos ?? []), ...(l.requestedSerialIds ?? []).map((s) => `#${s}`)].join(", ") || "—"}
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </div>
+
+        <ApprovalPanel
+          what="stock adjustment"
+          requiredApprovals={a.requiredApprovals}
+          pendingLevel={a.pendingLevel}
+          history={a.approvalHistory ?? []}
+          requestedByLabel={a.createdByName ?? `user #${a.createdBy}`}
+          requestedAt={a.createdAt}
+          canApprove={a.canApprove}
+          whyNot={a.whyNot}
+          canWithdraw={a.canWithdraw}
+          finalEffect="Stock moves and the inventory journal is posted to the ledger."
+          outcome={outcome}
+          outcomeAt={a.postedAt}
+          rejectReason={a.rejectReason}
+          onApprove={async (comment) => {
+            try {
+              const next = await stockAdjustmentsApi.approve(a.adjustmentId, comment)
+              setAdjustment(next)
+              toast.success(next.status === "Posted" ? "Approved and posted" : "Approved", next.status === "Posted" ? `${next.docNo} — stock updated.` : `${next.docNo} now needs a second approval.`)
+            } catch (err) {
+              toast.error("Could not approve", errorMessage(err))
+              throw err
+            }
+          }}
+          onReject={async (reasonText) => {
+            try {
+              setAdjustment(await stockAdjustmentsApi.reject(a.adjustmentId, reasonText))
+              toast.success("Adjustment rejected", a.docNo)
+            } catch (err) {
+              toast.error("Could not reject", errorMessage(err))
+              throw err
+            }
+          }}
+          onWithdraw={async () => {
+            try {
+              setAdjustment(await stockAdjustmentsApi.cancel(a.adjustmentId))
+              toast.success("Request withdrawn", a.docNo)
+            } catch (err) {
+              toast.error("Could not withdraw", errorMessage(err))
+              throw err
+            }
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function BackLink() {
+  return (
+    <Link href="/dashboard/stock/adjustments" className="inline-flex w-fit items-center gap-1.5 text-sm font-medium text-muted-foreground hover:text-foreground">
+      <ArrowLeft className="size-4" />
+      Stock Adjustments
+    </Link>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/stock/adjustments/new/page.tsx b/Frontend/erp-system/app/dashboard/stock/adjustments/new/page.tsx
index 2e5f5d2..ea43eda 100644
--- a/Frontend/erp-system/app/dashboard/stock/adjustments/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/adjustments/new/page.tsx
@@ -14,6 +14,9 @@ import { cn } from "@/lib/utils"
 import { CreateAdjustmentLineInput, ReasonCode, StockAdjustment } from "@/types/stock"
 import { ItemListItem, Warehouse } from "@/types/master-data"
 import { Branch } from "@/types/hrm"
+import { SalesLineSerial } from "@/types/tracking"
+import { LineTrackingPicker } from "@/components/sales/LineTrackingPicker"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 
 import { useAuth } from "@/components/auth/AuthProvider"
 import { Button, buttonVariants } from "@/components/ui/button"
@@ -29,6 +32,14 @@ interface DraftLine {
   key: string
   itemId: number | null
   qtyDelta: string
+  /** Serial item, negative delta: the units written off. */
+  serials: SalesLineSerial[]
+  /** Serial item, positive delta: the serial numbers found, one per line/comma. */
+  serialNos: string
+}
+
+function parseSerialNos(text: string): string[] {
+  return text.split(/[\r\n,;\t]+/).map((s) => s.trim()).filter((s) => s.length > 0)
 }
 
 let keySeq = 0
@@ -38,11 +49,12 @@ function newKey() {
 }
 
 function emptyLine(): DraftLine {
-  return { key: newKey(), itemId: null, qtyDelta: "" }
+  return { key: newKey(), itemId: null, qtyDelta: "", serials: [], serialNos: "" }
 }
 
 export default function NewAdjustmentPage() {
   const { isAdmin, branchId: myBranchId, activeBranchId, activeBranchName, branchingEnabled } = useAuth()
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   const [warehouses, setWarehouses] = useState<Warehouse[] | null>(null)
   const [items, setItems] = useState<ItemListItem[] | null>(null)
@@ -90,6 +102,41 @@ export default function NewAdjustmentPage() {
     setLines((prev) => (prev.length > 1 ? prev.filter((l) => l.key !== key) : prev))
   }
 
+  // Serial numbers switched off in Product Configuration: serial items adjust like plain stock.
+  const isSerialItem = (itemId: number | null) =>
+    serialNumbersEnabled !== false && items?.find((i) => i.itemId === itemId)?.trackingMode === "Serial"
+
+  /**
+   * Serial items only: a write-off (negative delta) picks the serials going out; a gain
+   * (positive delta) takes the serial numbers found, one per line or comma-separated.
+   */
+  function renderSerials(line: DraftLine) {
+    if (!line.itemId || !isSerialItem(line.itemId)) return null
+    const delta = Number(line.qtyDelta) || 0
+    if (delta < 0)
+      return (
+        <LineTrackingPicker
+          itemId={line.itemId}
+          warehouseId={warehouseId}
+          trackingMode="Serial"
+          units={-delta}
+          value={{ batchId: null, batchNo: null, serials: line.serials }}
+          onChange={(v) => updateLine(line.key, { serials: v.serials })}
+        />
+      )
+    if (delta > 0)
+      return (
+        <textarea
+          value={line.serialNos}
+          onChange={(e) => updateLine(line.key, { serialNos: e.target.value })}
+          placeholder={`${delta} serial number(s) found — one per line`}
+          rows={2}
+          className="mt-1 w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm"
+        />
+      )
+    return null
+  }
+
   async function handleSubmit() {
     setSubmitError(null)
 
@@ -110,6 +157,13 @@ export default function NewAdjustmentPage() {
     for (const line of lines) {
       if (!line.itemId) nextLineErrors[line.key] = "Select an item"
       else if (!line.qtyDelta || Number(line.qtyDelta) === 0) nextLineErrors[line.key] = "Enter a non-zero quantity change"
+      else if (isSerialItem(line.itemId)) {
+        const delta = Number(line.qtyDelta)
+        const count = delta < 0 ? line.serials.length : parseSerialNos(line.serialNos).length
+        if (!Number.isInteger(delta)) nextLineErrors[line.key] = "Serial items change in whole units"
+        else if (count !== Math.abs(delta))
+          nextLineErrors[line.key] = `${delta < 0 ? "Select" : "Enter"} ${Math.abs(delta)} serial number(s) — ${count} given`
+      }
     }
     setLineErrors(nextLineErrors)
     if (Object.keys(nextLineErrors).length > 0) {
@@ -120,6 +174,8 @@ export default function NewAdjustmentPage() {
     const payloadLines: CreateAdjustmentLineInput[] = lines.map((l) => ({
       itemId: l.itemId as number,
       qtyDelta: Number(l.qtyDelta),
+      serialIds: isSerialItem(l.itemId) && Number(l.qtyDelta) < 0 ? l.serials.map((s) => s.serialId) : null,
+      serialNos: isSerialItem(l.itemId) && Number(l.qtyDelta) > 0 ? parseSerialNos(l.serialNos) : null,
     }))
 
     setSubmitting(true)
@@ -131,10 +187,11 @@ export default function NewAdjustmentPage() {
         lines: payloadLines,
       })
       setResult(adjustment)
-      toast.success("Adjustment posted", `${adjustment.docNo} posted immediately (auto-post, FR-STK-07).`)
+      if (adjustment.status === "Posted") toast.success("Adjustment posted", `${adjustment.docNo} — stock updated.`)
+      else toast.success("Submitted for approval", `${adjustment.docNo} moves stock once ${adjustment.requiredApprovals === 2 ? "two people approve it" : "it is approved"}.`)
     } catch (err) {
       setSubmitError(errorMessage(err))
-      toast.error("Could not post adjustment", errorMessage(err))
+      toast.error("Could not submit adjustment", errorMessage(err))
     } finally {
       setSubmitting(false)
     }
@@ -168,9 +225,20 @@ export default function NewAdjustmentPage() {
           <div className="flex flex-col gap-2 rounded-xl border border-success/30 bg-success/5 p-5">
             <div className="flex items-center gap-2 text-success">
               <CheckCircle2 className="size-6" />
-              <p className="text-base font-semibold">{result.docNo} posted</p>
+              <p className="text-base font-semibold">
+                {result.status === "Posted" ? `${result.docNo} posted` : `${result.docNo} submitted for approval`}
+              </p>
+            </div>
+            <div className="text-sm text-muted-foreground">
+              {result.status === "Posted" ? (
+                <>Ledger refs: {result.ledgerRefs.join(", ")}</>
+              ) : (
+                <>
+                  Stock has not moved yet — it needs {result.requiredApprovals === 2 ? "two approvals from two different people" : "one approval"} (not yours).{" "}
+                  <Link href={`/dashboard/stock/adjustments/${result.adjustmentId}`} className="font-medium text-primary hover:underline">View request</Link>
+                </>
+              )}
             </div>
-            <div className="text-sm text-muted-foreground">Ledger refs: {result.ledgerRefs.join(", ")}</div>
           </div>
           <div className="flex gap-3">
             <Link href="/dashboard/stock/adjustments" className={cn(buttonVariants({ variant: "outline", size: "lg" }))}>
@@ -290,6 +358,7 @@ export default function NewAdjustmentPage() {
                       className="h-11 text-base"
                     />
                     <FieldError errors={[lineErrors[line.key] ? { message: lineErrors[line.key] } : undefined]} />
+                    {renderSerials(line)}
                   </div>
                 </div>
               ))}
@@ -333,6 +402,7 @@ export default function NewAdjustmentPage() {
                           className="h-11 text-base"
                         />
                         <FieldError errors={[lineErrors[line.key] ? { message: lineErrors[line.key] } : undefined]} />
+                        {renderSerials(line)}
                       </TableCell>
                       <TableCell className="px-3 py-3 align-top">
                         <Button type="button" variant="ghost" size="icon" onClick={() => removeLine(line.key)} aria-label="Remove line">
@@ -355,7 +425,7 @@ export default function NewAdjustmentPage() {
               Cancel
             </Link>
             <Button size="lg" type="button" className="w-full sm:w-auto" onClick={handleSubmit} disabled={submitting}>
-              {submitting ? "Posting…" : "Post Adjustment"}
+              {submitting ? "Submitting…" : "Submit for approval"}
             </Button>
           </div>
         </>
diff --git a/Frontend/erp-system/app/dashboard/stock/adjustments/page.tsx b/Frontend/erp-system/app/dashboard/stock/adjustments/page.tsx
index 4718689..0d2d50a 100644
--- a/Frontend/erp-system/app/dashboard/stock/adjustments/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/adjustments/page.tsx
@@ -2,6 +2,7 @@
 
 import { useEffect, useState } from "react"
 import Link from "next/link"
+import { useRouter } from "next/navigation"
 import { Plus, Search, SlidersHorizontal } from "lucide-react"
 
 import { stockAdjustmentsApi } from "@/lib/api/stock-adjustments"
@@ -10,24 +11,38 @@ import { reasonCodesApi } from "@/lib/api/reason-codes"
 import { errorMessage } from "@/lib/error-map"
 import { cn } from "@/lib/utils"
 import { PaginationMeta } from "@/types/common"
-import { StockAdjustmentSummary } from "@/types/stock"
+import { AdjustmentStatus, StockAdjustmentSummary } from "@/types/stock"
 import { Warehouse } from "@/types/master-data"
 
 import { useAuth } from "@/components/auth/AuthProvider"
 import { Button, buttonVariants } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
 import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
 import { Skeleton } from "@/components/ui/skeleton"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { AdjustmentStatusBadge } from "@/components/stock/status-badges"
+import { ApprovalQueueButton } from "@/components/approvals/ApprovalQueueButton"
 
 const PAGE_SIZE_OPTIONS = [5, 10, 15, 20]
 // Mobile has no page-size selector — tapping "Show more" just grows the page size and
 // re-fetches from page 1, so previously loaded cards stay put and more append below.
 const MOBILE_PAGE_SIZE_STEP = 10
 
+type StatusFilter = AdjustmentStatus | "All"
+const statusOptions: { value: StatusFilter; label: string }[] = [
+  { value: "All", label: "All statuses" },
+  { value: "PendingApproval", label: "Pending 1st approval" },
+  { value: "PendingSecondApproval", label: "Pending 2nd approval" },
+  { value: "Posted", label: "Posted" },
+  { value: "Rejected", label: "Rejected" },
+  { value: "Cancelled", label: "Withdrawn" },
+]
+
 export default function AdjustmentsListPage() {
   const { activeBranchId, branchingEnabled } = useAuth()
+  const router = useRouter()
+  const [status, setStatus] = useState<StatusFilter>("All")
 
   const [adjustments, setAdjustments] = useState<StockAdjustmentSummary[] | null>(null)
   const [warehouses, setWarehouses] = useState<Warehouse[] | null>(null)
@@ -46,19 +61,22 @@ export default function AdjustmentsListPage() {
     return () => clearTimeout(timeout)
   }, [searchInput])
 
-  useEffect(() => setPage(1), [query])
+  useEffect(() => setPage(1), [query, status])
 
   useEffect(() => {
     setError(null)
     stockAdjustmentsApi
-      .list({ page, pageSize, q: query || undefined, branchId: branchingEnabled ? (activeBranchId ?? undefined) : undefined })
+      .list({
+        page, pageSize, q: query || undefined, status: status === "All" ? undefined : status,
+        branchId: branchingEnabled ? (activeBranchId ?? undefined) : undefined,
+      })
       .then((res) => {
         setAdjustments(res.items)
         setPagination(res.pagination)
       })
       .catch((err) => setError(errorMessage(err)))
       .finally(() => setShowMoreLoading(false))
-  }, [page, pageSize, query, activeBranchId, branchingEnabled])
+  }, [page, pageSize, query, status, activeBranchId, branchingEnabled])
 
   function handleShowMore() {
     setShowMoreLoading(true)
@@ -75,7 +93,8 @@ export default function AdjustmentsListPage() {
   }, [])
 
   const whCode = (id: number) => warehouses?.find((w) => w.warehouseId === id)?.code ?? `#${id}`
-  const hasFilters = query.length > 0
+  const hasFilters = query.length > 0 || status !== "All"
+  const open = (id: number) => router.push(`/dashboard/stock/adjustments/${id}`)
 
   return (
     <div className="flex flex-col gap-6">
@@ -83,13 +102,18 @@ export default function AdjustmentsListPage() {
         <div className="flex items-center gap-3">
           <div>
             <h1 className="text-2xl font-bold text-foreground">Stock Adjustments</h1>
-            <p className="text-base text-muted-foreground">Increase, decrease, or write off stock with a reason code (FR-STK-07).</p>
+            <p className="text-base text-muted-foreground">
+              Increase, decrease, or write off stock with a reason code (FR-STK-07). Each adjustment is a request — stock moves once it is approved.
+            </p>
           </div>
         </div>
-        <Link href="/dashboard/stock/adjustments/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
-          <Plus className="size-5" />
-          New Adjustment
-        </Link>
+        <div className="flex flex-col gap-2 sm:flex-row">
+          <ApprovalQueueButton docType="ADJ" />
+          <Link href="/dashboard/stock/adjustments/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
+            <Plus className="size-5" />
+            New Adjustment
+          </Link>
+        </div>
       </div>
 
       <div className="flex flex-col gap-3 sm:flex-row sm:items-center">
@@ -103,6 +127,14 @@ export default function AdjustmentsListPage() {
             aria-label="Search stock adjustments"
           />
         </div>
+        <Select<StatusFilter> value={status} onValueChange={(v) => setStatus(v ?? "All")}>
+          <SelectTrigger className="h-12! w-full text-base sm:w-56" aria-label="Status">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent>
+            {statusOptions.map((o) => <SelectItem key={o.value} value={o.value} className="text-base">{o.label}</SelectItem>)}
+          </SelectContent>
+        </Select>
       </div>
 
       {error && (
@@ -147,7 +179,14 @@ export default function AdjustmentsListPage() {
           {/* Mobile: stacked cards. */}
           <div className="flex flex-col gap-3 md:hidden">
             {adjustments.map((a) => (
-              <div key={a.adjustmentId} className="flex flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm">
+              <div
+                key={a.adjustmentId}
+                role="link"
+                tabIndex={0}
+                onClick={() => open(a.adjustmentId)}
+                onKeyDown={(e) => { if (e.key === "Enter") open(a.adjustmentId) }}
+                className="flex cursor-pointer flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm"
+              >
                 <div className="flex items-start justify-between gap-2">
                   <p className="truncate font-semibold text-foreground">{a.docNo}</p>
                   <AdjustmentStatusBadge status={a.status} />
@@ -197,8 +236,10 @@ export default function AdjustmentsListPage() {
                 </TableHeader>
                 <TableBody>
                   {adjustments.map((a) => (
-                    <TableRow key={a.adjustmentId} className="align-top hover:bg-muted/20">
-                      <TableCell className="font-semibold text-foreground">{a.docNo}</TableCell>
+                    <TableRow key={a.adjustmentId} className="cursor-pointer align-top hover:bg-muted/20" onClick={() => open(a.adjustmentId)}>
+                      <TableCell className="font-semibold text-foreground">
+                        <Link href={`/dashboard/stock/adjustments/${a.adjustmentId}`} className="hover:underline">{a.docNo}</Link>
+                      </TableCell>
                       <TableCell className="text-sm text-muted-foreground">{whCode(a.warehouseId)}</TableCell>
                       <TableCell className="text-sm text-muted-foreground">{reasonLabels.get(a.reasonCodeId) ?? `#${a.reasonCodeId}`}</TableCell>
                       <TableCell>
diff --git a/Frontend/erp-system/app/dashboard/stock/batches/page.tsx b/Frontend/erp-system/app/dashboard/stock/batches/page.tsx
new file mode 100644
index 0000000..dafe6a8
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/stock/batches/page.tsx
@@ -0,0 +1,147 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+import { trackingApi } from "@/lib/api/tracking"
+import { warehousesApi } from "@/lib/api/warehouses"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { PagedResponse } from "@/types/common"
+import { Warehouse } from "@/types/master-data"
+import { BatchStock } from "@/types/tracking"
+
+import { Badge } from "@/components/ui/badge"
+import { Input } from "@/components/ui/input"
+import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+
+const WINDOWS: { label: string; days: number | null }[] = [
+  { label: "All batches", days: null },
+  { label: "Expired or within 7 days", days: 7 },
+  { label: "Expired or within 30 days", days: 30 },
+  { label: "Expired or within 90 days", days: 90 },
+]
+
+/** Batch stock with expiry (docs/ITEM_TRACKING_PLAN.md Phase 9) — soonest expiry first. */
+export default function BatchExpiryPage() {
+  const [warehouses, setWarehouses] = useState<Warehouse[]>([])
+  const [warehouseId, setWarehouseId] = useState<number | null>(null)
+  const [windowDays, setWindowDays] = useState<number | null>(30)
+  const [q, setQ] = useState("")
+  const [page, setPage] = useState(1)
+  const [data, setData] = useState<PagedResponse<BatchStock> | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    warehousesApi.list().then((r) => setWarehouses(r.items)).catch(() => setWarehouses([]))
+  }, [])
+
+  useEffect(() => {
+    let cancelled = false
+    const timer = setTimeout(() => {
+      trackingApi
+        .listBatchStock({ q: q.trim() || undefined, warehouseId: warehouseId ?? undefined, expiringWithinDays: windowDays ?? undefined, page, pageSize: 25 })
+        .then((r) => { if (!cancelled) { setData(r); setError(null) } })
+        .catch((err) => { if (!cancelled) setError(errorMessage(err)) })
+    }, 250)
+    return () => { cancelled = true; clearTimeout(timer) }
+  }, [q, warehouseId, windowDays, page])
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Batch Expiry</h1>
+        <p className="text-base text-muted-foreground">
+          Stock on hand per batch. Expired batches can no longer be issued; sales pick the soonest-expiring batch first.
+        </p>
+      </div>
+
+      <div className="flex flex-wrap items-end gap-3">
+        <Input
+          value={q}
+          onChange={(e) => { setPage(1); setQ(e.target.value) }}
+          placeholder="Search batch, SKU or item…"
+          className="h-11 min-w-64 flex-1 text-base"
+        />
+        <Select<number | null> value={windowDays} onValueChange={(v) => { setPage(1); setWindowDays(v) }}>
+          <SelectTrigger className="h-11! w-60 text-sm">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent>
+            {WINDOWS.map((w) => (
+              <SelectItem key={w.label} value={w.days} className="text-sm">{w.label}</SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        <Select<number | null> value={warehouseId} onValueChange={(v) => { setPage(1); setWarehouseId(v) }}>
+          <SelectTrigger className="h-11! w-48 text-sm">
+            <SelectValue placeholder="All warehouses" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value={null} className="text-sm">All warehouses</SelectItem>
+            {warehouses.map((w) => (
+              <SelectItem key={w.warehouseId} value={w.warehouseId} className="text-sm">{w.name}</SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!data && !error && <Skeleton className="h-40 w-full" />}
+
+      {data && data.items.length === 0 && (
+        <div className="rounded-xl border border-dashed py-16 text-center text-base text-muted-foreground">No batch stock in this window.</div>
+      )}
+
+      {data && data.items.length > 0 && (
+        <div className="overflow-x-auto">
+          <Table className="text-sm">
+            <TableHeader>
+              <TableRow>
+                <TableHead className="px-3">Item</TableHead>
+                <TableHead className="px-3">Batch</TableHead>
+                <TableHead className="px-3">Warehouse</TableHead>
+                <TableHead className="px-3">Expiry</TableHead>
+                <TableHead className="px-3 text-right">Qty on hand</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {data.items.map((b) => (
+                <TableRow key={`${b.itemId}-${b.warehouseId}-${b.batchId}`}>
+                  <TableCell className="px-3 py-3">
+                    <div className="font-medium">{b.sku}</div>
+                    <div className="text-xs text-muted-foreground">{b.itemName}</div>
+                  </TableCell>
+                  <TableCell className="px-3 py-3 font-mono">{b.batchNo}</TableCell>
+                  <TableCell className="px-3 py-3">{b.warehouseName}</TableCell>
+                  <TableCell className="px-3 py-3">
+                    {b.expiryDate ? (
+                      <span className="flex items-center gap-2">
+                        {b.expiryDate}
+                        <Badge
+                          variant="outline"
+                          className={cn(
+                            "text-xs",
+                            b.isExpired ? "border-destructive/40 text-destructive" : (b.daysToExpiry ?? 999) <= 30 ? "border-warning/50 text-warning" : "text-muted-foreground"
+                          )}
+                        >
+                          {b.isExpired ? "Expired" : `${b.daysToExpiry} days`}
+                        </Badge>
+                      </span>
+                    ) : (
+                      <span className="text-muted-foreground">No expiry</span>
+                    )}
+                  </TableCell>
+                  <TableCell className="px-3 py-3 text-right tabular-nums">{b.qty}</TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+          <PaginationFooter pagination={data.pagination} onPageChange={setPage} />
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/stock/counts/[id]/page.tsx b/Frontend/erp-system/app/dashboard/stock/counts/[id]/page.tsx
index 52e4bac..9a5ac06 100644
--- a/Frontend/erp-system/app/dashboard/stock/counts/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/counts/[id]/page.tsx
@@ -1,6 +1,7 @@
 "use client"
 
 import { useEffect, useRef, useState } from "react"
+import Link from "next/link"
 import { useParams } from "next/navigation"
 import { CheckCircle2, ClipboardCheck, Save } from "lucide-react"
 
@@ -103,7 +104,13 @@ export default function CountDetailPage() {
       const result = await stockCountsApi.post(countId)
       setPostResult(result)
       setCount((prev) => (prev ? { ...prev, status: result.status } : prev))
-      toast.success("Count posted", `Variance adjustment ${result.adjustmentId} created.`)
+      const pending = result.adjustmentStatus && result.adjustmentStatus !== "Posted"
+      toast.success(
+        "Count posted",
+        result.adjustmentId === null ? "No variances — nothing to adjust."
+        : pending ? `Variances submitted for approval as ${result.adjustmentDocNo ?? `adjustment #${result.adjustmentId}`}.`
+        : `Variance adjustment ${result.adjustmentDocNo ?? result.adjustmentId} posted.`
+      )
     } catch (err) {
       setError(errorMessage(err))
       toast.error("Could not post count", errorMessage(err))
@@ -171,9 +178,22 @@ export default function CountDetailPage() {
         <div className="flex flex-col gap-2 rounded-xl border border-success/30 bg-success/5 p-5">
           <div className="flex items-center gap-2 text-success">
             <CheckCircle2 className="size-6" />
-            <p className="text-base font-semibold">Posted — variance adjustment #{postResult.adjustmentId} created</p>
+            <p className="text-base font-semibold">
+              {postResult.adjustmentId === null
+                ? "Posted — no variances"
+                : postResult.adjustmentStatus && postResult.adjustmentStatus !== "Posted"
+                  ? `Posted — variances submitted for approval (${postResult.adjustmentDocNo ?? `#${postResult.adjustmentId}`})`
+                  : `Posted — variance adjustment ${postResult.adjustmentDocNo ?? `#${postResult.adjustmentId}`} created`}
+            </p>
           </div>
-          <div className="text-sm text-muted-foreground">Ledger refs: {postResult.ledgerRefs.join(", ") || "none (no variance)"}</div>
+          {postResult.adjustmentId !== null && postResult.adjustmentStatus && postResult.adjustmentStatus !== "Posted" ? (
+            <div className="text-sm text-muted-foreground">
+              Stock moves once the variance adjustment is approved.{" "}
+              <Link href={`/dashboard/stock/adjustments/${postResult.adjustmentId}`} className="font-medium text-primary hover:underline">View request</Link>
+            </div>
+          ) : (
+            <div className="text-sm text-muted-foreground">Ledger refs: {postResult.ledgerRefs.join(", ") || "none (no variance)"}</div>
+          )}
           {postResult.glJournalNo && (
             <div className="text-sm text-muted-foreground">GL journal: <span className="font-medium text-foreground">{postResult.glJournalNo}</span></div>
           )}
diff --git a/Frontend/erp-system/app/dashboard/stock/serials/page.tsx b/Frontend/erp-system/app/dashboard/stock/serials/page.tsx
new file mode 100644
index 0000000..b57d6cb
--- /dev/null
+++ b/Frontend/erp-system/app/dashboard/stock/serials/page.tsx
@@ -0,0 +1,244 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { ScanLine, X } from "lucide-react"
+
+import { trackingApi } from "@/lib/api/tracking"
+import { warehousesApi } from "@/lib/api/warehouses"
+import { errorMessage } from "@/lib/error-map"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
+import { cn } from "@/lib/utils"
+import { PagedResponse } from "@/types/common"
+import { Warehouse } from "@/types/master-data"
+import { SerialDetail, SerialStatus, SerialSummary } from "@/types/tracking"
+
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { PaginationFooter } from "@/components/ui/pagination-footer"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+
+const STATUSES: SerialStatus[] = ["InStock", "InTransit", "Sold", "ReturnedByCustomer", "ReturnedToVendor", "Damaged", "Scrapped", "IssuedUntracked"]
+
+const STATUS_TONE: Partial<Record<SerialStatus, string>> = {
+  InStock: "border-success/40 text-success",
+  InTransit: "border-info/40 text-info",
+  Sold: "border-muted-foreground/30 text-muted-foreground",
+  Damaged: "border-warning/50 text-warning",
+  Scrapped: "border-destructive/40 text-destructive",
+  ReturnedToVendor: "border-muted-foreground/30 text-muted-foreground",
+}
+
+/** Friendly names for the document-type prefixes a serial movement references. */
+const DOC_LABEL: Record<string, string> = {
+  GRN: "Goods receipt",
+  SI: "Sales invoice",
+  SSL: "Sales slip",
+  BND: "Bundle sale",
+  SRET: "Sales return",
+  PRET: "Purchase return",
+  TRF: "Transfer",
+  ADJ: "Adjustment",
+  CNT: "Stock count",
+}
+
+function SerialStatusBadge({ status }: { status: SerialStatus }) {
+  return (
+    <Badge variant="outline" className={cn("text-xs", STATUS_TONE[status])}>
+      {status.replace(/([a-z])([A-Z])/g, "$1 $2")}
+    </Badge>
+  )
+}
+
+/** Serial register (docs/ITEM_TRACKING_PLAN.md Phase 9): every serial, its status and location, and its history. */
+export default function SerialsPage() {
+  const [warehouses, setWarehouses] = useState<Warehouse[]>([])
+  const [q, setQ] = useState("")
+  const [search, setSearch] = useState("")
+  const [status, setStatus] = useState<SerialStatus | null>(null)
+  const [warehouseId, setWarehouseId] = useState<number | null>(null)
+  const [page, setPage] = useState(1)
+  const [data, setData] = useState<PagedResponse<SerialSummary> | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [detail, setDetail] = useState<SerialDetail | null>(null)
+  const { serialNumbersEnabled } = useTrackingSettings()
+
+  useEffect(() => {
+    warehousesApi.list().then((r) => setWarehouses(r.items)).catch(() => setWarehouses([]))
+  }, [])
+
+  useEffect(() => {
+    let cancelled = false
+    trackingApi
+      .listSerials({ q: search || undefined, status: status ?? undefined, warehouseId: warehouseId ?? undefined, page, pageSize: 25 })
+      .then((r) => { if (!cancelled) { setData(r); setError(null) } })
+      .catch((err) => { if (!cancelled) setError(errorMessage(err)) })
+    return () => { cancelled = true }
+  }, [search, status, warehouseId, page])
+
+  async function openDetail(serialId: number) {
+    try {
+      setDetail(await trackingApi.getSerial(serialId))
+    } catch (err) {
+      setError(errorMessage(err))
+    }
+  }
+
+  const warehouseName = (id: number | null) => (id ? warehouses.find((w) => w.warehouseId === id)?.name ?? `#${id}` : "—")
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Serials</h1>
+        <p className="text-base text-muted-foreground">Every serial-tracked unit — where it is, what happened to it, and its warranty.</p>
+      </div>
+
+      {serialNumbersEnabled === false && (
+        <div className="rounded-lg border border-warning/40 bg-warning/10 p-4 text-sm text-foreground">
+          Serial numbers are switched off in Products → Configuration. This is past history only — no new
+          serials are recorded, and units issued meanwhile show as “Issued Untracked”.
+        </div>
+      )}
+
+      <div className="flex flex-wrap items-end gap-3">
+        <form
+          className="flex min-w-64 flex-1 gap-2"
+          onSubmit={(e) => {
+            e.preventDefault()
+            setPage(1)
+            setSearch(q.trim())
+          }}
+        >
+          <Input value={q} onChange={(e) => setQ(e.target.value)} placeholder="Scan or search serial, SKU or item…" className="h-11 text-base" />
+          <Button type="submit" className="h-11">
+            <ScanLine className="size-4" />
+            Search
+          </Button>
+        </form>
+        <Select<SerialStatus | null> value={status} onValueChange={(v) => { setPage(1); setStatus(v) }}>
+          <SelectTrigger className="h-11! w-48 text-sm">
+            <SelectValue placeholder="All statuses" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value={null} className="text-sm">All statuses</SelectItem>
+            {STATUSES.map((s) => (
+              <SelectItem key={s} value={s} className="text-sm">{s.replace(/([a-z])([A-Z])/g, "$1 $2")}</SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        <Select<number | null> value={warehouseId} onValueChange={(v) => { setPage(1); setWarehouseId(v) }}>
+          <SelectTrigger className="h-11! w-48 text-sm">
+            <SelectValue placeholder="All warehouses" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value={null} className="text-sm">All warehouses</SelectItem>
+            {warehouses.map((w) => (
+              <SelectItem key={w.warehouseId} value={w.warehouseId} className="text-sm">{w.name}</SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      {error && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>}
+      {!data && !error && <Skeleton className="h-40 w-full" />}
+
+      {data && data.items.length === 0 && (
+        <div className="rounded-xl border border-dashed py-16 text-center text-base text-muted-foreground">
+          No serials match. Serials are created when a GRN for a serial-tracked item is confirmed.
+        </div>
+      )}
+
+      {data && data.items.length > 0 && (
+        <div className="overflow-x-auto">
+          <Table className="text-sm">
+            <TableHeader>
+              <TableRow>
+                <TableHead className="px-3">Serial</TableHead>
+                <TableHead className="px-3">Item</TableHead>
+                <TableHead className="px-3">Status</TableHead>
+                <TableHead className="px-3">Warehouse</TableHead>
+                <TableHead className="px-3">Received</TableHead>
+                <TableHead className="px-3">GRN</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {data.items.map((s) => (
+                <TableRow key={s.serialId} className="cursor-pointer" onClick={() => openDetail(s.serialId)}>
+                  <TableCell className="px-3 py-3 font-mono">{s.serialNo}</TableCell>
+                  <TableCell className="px-3 py-3">
+                    <div className="font-medium">{s.sku}</div>
+                    <div className="text-xs text-muted-foreground">{s.itemName}</div>
+                  </TableCell>
+                  <TableCell className="px-3 py-3"><SerialStatusBadge status={s.status} /></TableCell>
+                  <TableCell className="px-3 py-3">{s.warehouseName ?? "—"}</TableCell>
+                  <TableCell className="px-3 py-3">{s.receivedAt ? new Date(s.receivedAt).toLocaleDateString() : "—"}</TableCell>
+                  <TableCell className="px-3 py-3">{s.grnDocNo ?? "—"}</TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+          <PaginationFooter pagination={data.pagination} onPageChange={setPage} />
+        </div>
+      )}
+
+      {detail && (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40 p-4" onClick={() => setDetail(null)}>
+          <div className="max-h-[85vh] w-full max-w-2xl overflow-y-auto rounded-xl bg-background p-6 shadow-xl" onClick={(e) => e.stopPropagation()}>
+            <div className="flex items-start justify-between gap-3">
+              <div>
+                <h2 className="font-mono text-xl font-bold">{detail.serial.serialNo}</h2>
+                <p className="text-sm text-muted-foreground">{detail.serial.sku} — {detail.serial.itemName}</p>
+              </div>
+              <Button type="button" variant="ghost" size="icon" onClick={() => setDetail(null)} aria-label="Close">
+                <X className="size-5" />
+              </Button>
+            </div>
+
+            <div className="mt-4 grid grid-cols-2 gap-3 text-sm sm:grid-cols-4">
+              <div><p className="text-muted-foreground">Status</p><SerialStatusBadge status={detail.serial.status} /></div>
+              <div><p className="text-muted-foreground">Warehouse</p><p>{detail.serial.warehouseName ?? "—"}</p></div>
+              <div><p className="text-muted-foreground">GRN</p><p>{detail.serial.grnDocNo ?? "—"}</p></div>
+              <div><p className="text-muted-foreground">Warranty</p><p>{detail.serial.warrantyPeriodMonths ? `${detail.serial.warrantyPeriodMonths} months` : "None"}</p></div>
+            </div>
+
+            {detail.warranties.length > 0 && (
+              <div className="mt-5">
+                <h3 className="mb-2 text-sm font-semibold">Warranty</h3>
+                {detail.warranties.map((w) => (
+                  <div key={w.warrantyRegistrationId} className="rounded-lg border p-3 text-sm">
+                    <p>
+                      {w.customerName} · {w.startDate} → {w.endDate}{" "}
+                      <Badge variant="outline" className={cn("ml-1 text-xs", w.status === "Active" && !w.isExpired ? "text-success" : "text-muted-foreground")}>
+                        {w.status === "Active" ? (w.isExpired ? "Expired" : `${w.daysRemaining} days left`) : w.status}
+                      </Badge>
+                    </p>
+                  </div>
+                ))}
+              </div>
+            )}
+
+            <div className="mt-5">
+              <h3 className="mb-2 text-sm font-semibold">History</h3>
+              {detail.history.length === 0 ? (
+                <p className="text-sm text-muted-foreground">No recorded movements.</p>
+              ) : (
+                <ol className="flex flex-col gap-2 border-l pl-4">
+                  {detail.history.map((m) => (
+                    <li key={m.serialMovementId} className="text-sm">
+                      <span className="text-muted-foreground">{new Date(m.createdAt).toLocaleString()}</span>{" — "}
+                      {DOC_LABEL[m.sourceDocType] ?? m.sourceDocType} #{m.sourceDocId}{" → "}
+                      <SerialStatusBadge status={m.status} />
+                      {m.warehouseId && <span className="text-muted-foreground"> at {warehouseName(m.warehouseId)}</span>}
+                    </li>
+                  ))}
+                </ol>
+              )}
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/app/dashboard/stock/transfers/new/page.tsx b/Frontend/erp-system/app/dashboard/stock/transfers/new/page.tsx
index d8764e4..e92c232 100644
--- a/Frontend/erp-system/app/dashboard/stock/transfers/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/transfers/new/page.tsx
@@ -14,6 +14,9 @@ import { cn } from "@/lib/utils"
 import { CreateTransferLineInput } from "@/types/stock"
 import { Bin, ItemListItem, Warehouse } from "@/types/master-data"
 import { Branch } from "@/types/hrm"
+import { SalesLineSerial } from "@/types/tracking"
+import { LineTrackingPicker } from "@/components/sales/LineTrackingPicker"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 
 import { Button, buttonVariants } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
@@ -29,6 +32,11 @@ interface DraftLine {
   itemId: number | null
   destBinId: number | null
   qty: string
+  /** Pinned batch (null = server splits FEFO for a batch item). */
+  batchId: number | null
+  batchNo: string | null
+  /** Serial item: the units being moved. */
+  serials: SalesLineSerial[]
 }
 
 let keySeq = 0
@@ -38,11 +46,12 @@ function newKey() {
 }
 
 function emptyLine(): DraftLine {
-  return { key: newKey(), itemId: null, destBinId: null, qty: "" }
+  return { key: newKey(), itemId: null, destBinId: null, qty: "", batchId: null, batchNo: null, serials: [] }
 }
 
 export default function NewTransferPage() {
   const router = useRouter()
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   const [warehouses, setWarehouses] = useState<Warehouse[] | null>(null)
   const [items, setItems] = useState<ItemListItem[] | null>(null)
@@ -114,6 +123,26 @@ export default function NewTransferPage() {
     setLines((prev) => (prev.length > 1 ? prev.filter((l) => l.key !== key) : prev))
   }
 
+  /** Changing a line's item clears its batch/serial picks — they belonged to the old item. */
+  function setLineItem(key: string, itemId: number | null) {
+    updateLine(key, { itemId, batchId: null, batchNo: null, serials: [] })
+  }
+
+  /** Serial / batch picker for a line, drawing on the source warehouse's stock. */
+  function renderTracking(line: DraftLine) {
+    if (!line.itemId) return null
+    return (
+      <LineTrackingPicker
+        itemId={line.itemId}
+        warehouseId={srcWarehouseId}
+        trackingMode={items?.find((i) => i.itemId === line.itemId)?.trackingMode}
+        units={Number(line.qty) || 0}
+        value={{ batchId: line.batchId, batchNo: line.batchNo, serials: line.serials }}
+        onChange={(v) => updateLine(line.key, { batchId: v.batchId, batchNo: v.batchNo, serials: v.serials })}
+      />
+    )
+  }
+
   async function handleSubmit() {
     setSubmitError(null)
 
@@ -132,8 +161,11 @@ export default function NewTransferPage() {
 
     const nextLineErrors: Record<string, string> = {}
     for (const line of lines) {
+      const serialItem = serialNumbersEnabled !== false && items?.find((i) => i.itemId === line.itemId)?.trackingMode === "Serial"
       if (!line.itemId) nextLineErrors[line.key] = "Select an item"
       else if (!line.qty || Number(line.qty) <= 0) nextLineErrors[line.key] = "Quantity must be greater than 0"
+      else if (serialItem && line.serials.length !== Number(line.qty))
+        nextLineErrors[line.key] = `Select ${Number(line.qty)} serial number(s) — ${line.serials.length} selected`
     }
     setLineErrors(nextLineErrors)
     if (Object.keys(nextLineErrors).length > 0) {
@@ -146,6 +178,8 @@ export default function NewTransferPage() {
       srcBinId,
       destBinId: l.destBinId,
       qty: Number(l.qty),
+      batchId: l.batchId,
+      serialIds: l.serials.length > 0 ? l.serials.map((s) => s.serialId) : null,
     }))
 
     setSubmitting(true)
@@ -269,7 +303,7 @@ export default function NewTransferPage() {
                   <div className="flex items-start gap-2">
                     <div className="flex-1">
                       <Label className="text-sm">Item</Label>
-                      <Select<number | null> value={line.itemId} onValueChange={(v) => updateLine(line.key, { itemId: v })}>
+                      <Select<number | null> value={line.itemId} onValueChange={(v) => setLineItem(line.key, v)}>
                         <SelectTrigger className="h-11! w-full text-base">
                           <SelectValue placeholder="Select item" />
                         </SelectTrigger>
@@ -281,6 +315,7 @@ export default function NewTransferPage() {
                           ))}
                         </SelectContent>
                       </Select>
+                      {renderTracking(line)}
                     </div>
                     <Button type="button" variant="ghost" size="icon" className="mt-6 shrink-0" onClick={() => removeLine(line.key)} aria-label="Remove line">
                       <Trash2 className="size-5" />
@@ -337,7 +372,7 @@ export default function NewTransferPage() {
                   {lines.map((line) => (
                     <TableRow key={line.key}>
                       <TableCell className="px-3 py-3 align-top">
-                        <Select<number | null> value={line.itemId} onValueChange={(v) => updateLine(line.key, { itemId: v })}>
+                        <Select<number | null> value={line.itemId} onValueChange={(v) => setLineItem(line.key, v)}>
                           <SelectTrigger className="h-11! w-full text-base">
                             <SelectValue placeholder="Select item" />
                           </SelectTrigger>
@@ -349,6 +384,7 @@ export default function NewTransferPage() {
                             ))}
                           </SelectContent>
                         </Select>
+                        {renderTracking(line)}
                       </TableCell>
                       <TableCell className="px-3 py-3 align-top">
                         <Select<number | null> value={line.destBinId} onValueChange={(v) => updateLine(line.key, { destBinId: v })}>
diff --git a/Frontend/erp-system/app/dashboard/stock/wastage/new/page.tsx b/Frontend/erp-system/app/dashboard/stock/wastage/new/page.tsx
index b1bc537..bdc3268 100644
--- a/Frontend/erp-system/app/dashboard/stock/wastage/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/wastage/new/page.tsx
@@ -111,7 +111,8 @@ export default function NewWastagePage() {
         reasonCodeId: reasonCodeId as number,
       })
       setResult(adjustment)
-      toast.success("Wastage recorded", `${adjustment.docNo} posted immediately (auto-post, FR-STK-07).`)
+      if (adjustment.status === "Posted") toast.success("Wastage recorded", `${adjustment.docNo} — stock written off.`)
+      else toast.success("Wastage submitted for approval", `${adjustment.docNo} is written off once ${adjustment.requiredApprovals === 2 ? "two people approve it" : "it is approved"}.`)
     } catch (err) {
       setSubmitError(errorMessage(err))
       toast.error("Could not record wastage", errorMessage(err))
@@ -152,9 +153,20 @@ export default function NewWastagePage() {
           <div className="flex flex-col gap-2 rounded-xl border border-success/30 bg-success/5 p-5">
             <div className="flex items-center gap-2 text-success">
               <CheckCircle2 className="size-6" />
-              <p className="text-base font-semibold">{result.docNo} posted</p>
+              <p className="text-base font-semibold">
+                {result.status === "Posted" ? `${result.docNo} posted` : `${result.docNo} submitted for approval`}
+              </p>
+            </div>
+            <div className="text-sm text-muted-foreground">
+              {result.status === "Posted" ? (
+                <>Ledger refs: {result.ledgerRefs.join(", ")}</>
+              ) : (
+                <>
+                  Stock is written off once approved.{" "}
+                  <Link href={`/dashboard/stock/adjustments/${result.adjustmentId}`} className="font-medium text-primary hover:underline">View request</Link>
+                </>
+              )}
             </div>
-            <div className="text-sm text-muted-foreground">Ledger refs: {result.ledgerRefs.join(", ")}</div>
           </div>
           <div className="flex gap-3">
             <Link href="/dashboard/stock/wastage" className={cn(buttonVariants({ variant: "outline", size: "lg" }))}>
diff --git a/Frontend/erp-system/app/dashboard/stock/wastage/page.tsx b/Frontend/erp-system/app/dashboard/stock/wastage/page.tsx
index ebec708..95b83ed 100644
--- a/Frontend/erp-system/app/dashboard/stock/wastage/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/wastage/page.tsx
@@ -10,6 +10,7 @@ import { warehousesApi } from "@/lib/api/warehouses"
 import { itemsApi } from "@/lib/api/items"
 import { errorMessage } from "@/lib/error-map"
 import { cn } from "@/lib/utils"
+import { ApprovalQueueButton } from "@/components/approvals/ApprovalQueueButton"
 import { ReasonCode } from "@/types/stock"
 import { ItemListItem, Warehouse } from "@/types/master-data"
 
@@ -92,10 +93,13 @@ export default function WastagePage() {
             </p>
           </div>
         </div>
-        <Link href="/dashboard/stock/wastage/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
-          <Plus className="size-5" />
-          Record Wastage
-        </Link>
+        <div className="flex flex-col gap-2 sm:flex-row">
+          <ApprovalQueueButton docType="ADJ" />
+          <Link href="/dashboard/stock/wastage/new" className={cn(buttonVariants({ size: "lg" }), "w-full sm:w-auto")}>
+            <Plus className="size-5" />
+            Record Wastage
+          </Link>
+        </div>
       </div>
 
       {error && (
@@ -200,7 +204,7 @@ export default function WastagePage() {
                   <div className="grid grid-cols-2 gap-3 border-t pt-3 text-sm">
                     <div>
                       <p className="text-muted-foreground">Doc No</p>
-                      <p className="font-medium text-foreground">{r.docNo}</p>
+                      <p className="font-medium text-foreground">{r.docNo}{r.status !== "Posted" && <span className="ml-2 rounded bg-warning/10 px-1.5 py-0.5 text-xs text-warning">Pending approval</span>}</p>
                     </div>
                     <div>
                       <p className="text-muted-foreground">Warehouse</p>
@@ -253,7 +257,7 @@ export default function WastagePage() {
                     const reason = reasonById.get(r.reasonCodeId)
                     return (
                       <TableRow key={`${r.adjustmentId}-${r.adjLineId}`} className="align-top hover:bg-muted/20">
-                        <TableCell className="font-semibold text-foreground">{r.docNo}</TableCell>
+                        <TableCell className="font-semibold text-foreground">{r.docNo}{r.status !== "Posted" && <span className="ml-2 rounded bg-warning/10 px-1.5 py-0.5 text-xs font-normal text-warning">Pending approval</span>}</TableCell>
                         <TableCell className="text-sm text-muted-foreground">{new Date(r.createdAt).toLocaleString()}</TableCell>
                         <TableCell className="font-semibold text-foreground">{item?.sku ?? `#${r.itemId}`}</TableCell>
                         <TableCell className="text-sm text-muted-foreground">{item?.name}</TableCell>
diff --git a/Frontend/erp-system/app/dashboard/vendors/[id]/page.tsx b/Frontend/erp-system/app/dashboard/vendors/[id]/page.tsx
index 1671a19..24c8ee1 100644
--- a/Frontend/erp-system/app/dashboard/vendors/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/vendors/[id]/page.tsx
@@ -77,9 +77,21 @@ export default function VendorDetailPage() {
       .catch(() => {})
   }, [vendorId])
 
+  /** Drops fields' errors once the user starts editing them. */
+  function clearErrors(...keys: string[]) {
+    setErrors((prev) => {
+      if (!keys.some((k) => prev[k])) return prev
+      const next = { ...prev }
+      for (const k of keys) delete next[k]
+      return next
+    })
+  }
+
   function handleNameChange(value: string) {
     setName(value)
     setCode(value.trim() ? generateVendorCode(value, otherVendorCodes) : "")
+    // The code is regenerated from the name, so its error is stale too.
+    clearErrors("name", "code")
   }
 
   function applyVendor(data: Vendor) {
@@ -457,7 +469,7 @@ export default function VendorDetailPage() {
               <FieldError errors={[errors.code ? { message: errors.code } : undefined]} />
             </div>
             <div className="flex flex-col gap-2">
-              <Label className="text-base">Name</Label>
+              <Label className="text-base" required>Name</Label>
               <Input value={name} onChange={(e) => handleNameChange(e.target.value)} aria-invalid={!!errors.name} className="h-12 text-base" disabled={conflict} />
               <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
             </div>
@@ -470,8 +482,8 @@ export default function VendorDetailPage() {
               <Input value={taxReg} onChange={(e) => setTaxReg(e.target.value)} className="h-12 text-base" disabled={conflict} />
             </div>
             <div className="flex flex-col gap-2">
-              <Label className="text-base">Currency</Label>
-              <Input value={currency} onChange={(e) => setCurrency(e.target.value)} maxLength={3} aria-invalid={!!errors.currency} className="h-12 text-base" disabled={conflict} />
+              <Label className="text-base" required>Currency</Label>
+              <Input value={currency} onChange={(e) => { setCurrency(e.target.value); clearErrors("currency") }} maxLength={3} aria-invalid={!!errors.currency} className="h-12 text-base" disabled={conflict} />
               <FieldError errors={[errors.currency ? { message: errors.currency } : undefined]} />
             </div>
           </div>
diff --git a/Frontend/erp-system/app/dashboard/vendors/page.tsx b/Frontend/erp-system/app/dashboard/vendors/page.tsx
index eb8b394..7f742c1 100644
--- a/Frontend/erp-system/app/dashboard/vendors/page.tsx
+++ b/Frontend/erp-system/app/dashboard/vendors/page.tsx
@@ -33,6 +33,7 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { Skeleton } from "@/components/ui/skeleton"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { toast } from "@/components/ui/toast"
+import { EditVendorDialog } from "@/components/vendors/EditVendorDialog"
 
 type StatusFilter = EntityStatus | "All"
 
@@ -69,6 +70,8 @@ export default function VendorsPage() {
   const [allVendorCodes, setAllVendorCodes] = useState<string[]>([])
 
   const [actionPendingId, setActionPendingId] = useState<number | null>(null)
+  // The vendor whose edit popup is open.
+  const [editingId, setEditingId] = useState<number | null>(null)
   const [showMoreLoading, setShowMoreLoading] = useState(false)
 
   const generatedCode = name.trim() ? generateVendorCode(name, allVendorCodes) : ""
@@ -130,6 +133,16 @@ export default function VendorsPage() {
     setErrors({})
   }
 
+  /** Drops a field's error once the user starts editing it. */
+  function clearError(key: string) {
+    setErrors((prev) => {
+      if (!prev[key]) return prev
+      const next = { ...prev }
+      delete next[key]
+      return next
+    })
+  }
+
   async function handleCreate() {
     const nextErrors: Record<string, string> = {}
     if (!name.trim()) nextErrors.name = "Vendor name is required"
@@ -155,14 +168,15 @@ export default function VendorsPage() {
     }
   }
 
-  // FR-MD-08: masters are deactivated, never hard-deleted — "Delete" in the UI
-  // maps to PATCH status → Inactive, same mechanism as the detail page's toggle.
-  async function handleDeactivate(vendor: Vendor) {
+  // Hard delete. The server refuses (409) a vendor any purchase document or item still
+  // references — those can only be deactivated, from the detail page's status toggle.
+  async function handleDelete(vendor: Vendor) {
     setActionPendingId(vendor.vendorId)
     try {
-      await vendorsApi.updateStatus(vendor.vendorId, "Inactive")
-      toast.success("Vendor deleted", `${vendor.code} has been deactivated.`)
+      await vendorsApi.delete(vendor.vendorId)
+      toast.success("Vendor deleted", `${vendor.code} — ${vendor.name}`)
       load()
+      setAllVendorCodes((codes) => codes.filter((c) => c !== vendor.code))
     } catch (err) {
       toast.error("Could not delete vendor", errorMessage(err))
     } finally {
@@ -170,6 +184,17 @@ export default function VendorsPage() {
     }
   }
 
+  /**
+   * Row click → detail page. React bubbles events out of portals along the component tree,
+   * so a click on the delete confirmation (portaled to <body>) still reaches the row; only
+   * navigate for events whose DOM target really is inside the row and not an action cell.
+   */
+  function openRow(e: React.MouseEvent | React.KeyboardEvent, vendorId: number) {
+    const target = e.target as HTMLElement
+    if (!e.currentTarget.contains(target) || target.closest("[data-no-row-nav]")) return
+    router.push(`/dashboard/vendors/${vendorId}`)
+  }
+
   const hasFilters = query.length > 0 || status !== "All"
 
   return (
@@ -196,8 +221,8 @@ export default function VendorsPage() {
             </DialogHeader>
             <FieldGroup>
               <Field data-invalid={!!errors.name}>
-                <FieldLabel htmlFor="v-name">Name</FieldLabel>
-                <Input id="v-name" value={name} onChange={(e) => setName(e.target.value)} placeholder="Lanka Steel Traders (Pvt) Ltd" aria-invalid={!!errors.name} />
+                <FieldLabel htmlFor="v-name" required>Name</FieldLabel>
+                <Input id="v-name" value={name} onChange={(e) => { setName(e.target.value); clearError("name") }} placeholder="Lanka Steel Traders (Pvt) Ltd" aria-invalid={!!errors.name} />
                 <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
               </Field>
               <Field>
@@ -213,14 +238,14 @@ export default function VendorsPage() {
                 <Input id="v-taxreg" value={taxReg} onChange={(e) => setTaxReg(e.target.value)} placeholder="134567890-7000" />
               </Field>
               <Field data-invalid={!!errors.currency}>
-                <FieldLabel htmlFor="v-currency">Currency</FieldLabel>
-                <Input id="v-currency" value={currency} onChange={(e) => setCurrency(e.target.value)} placeholder="LKR" maxLength={3} aria-invalid={!!errors.currency} />
+                <FieldLabel htmlFor="v-currency" required>Currency</FieldLabel>
+                <Input id="v-currency" value={currency} onChange={(e) => { setCurrency(e.target.value); clearError("currency") }} placeholder="LKR" maxLength={3} aria-invalid={!!errors.currency} />
                 <FieldError errors={[errors.currency ? { message: errors.currency } : undefined]} />
               </Field>
               {showBranchPicker && (
                 <Field data-invalid={!!errors.branch}>
-                  <FieldLabel htmlFor="v-branch">Branch</FieldLabel>
-                  <Select<number | null> value={branchFilterId} onValueChange={(v) => setBranchFilterId(v)}>
+                  <FieldLabel htmlFor="v-branch" required>Branch</FieldLabel>
+                  <Select<number | null> value={branchFilterId} onValueChange={(v) => { setBranchFilterId(v); clearError("branch") }}>
                     <SelectTrigger id="v-branch" className="w-full" aria-invalid={!!errors.branch}>
                       <SelectValue placeholder="Select branch" />
                     </SelectTrigger>
@@ -311,12 +336,9 @@ export default function VendorsPage() {
                 key={v.vendorId}
                 role="link"
                 tabIndex={0}
-                onClick={(e) => {
-                  if ((e.target as HTMLElement).closest("[data-no-row-nav]")) return
-                  router.push(`/dashboard/vendors/${v.vendorId}`)
-                }}
+                onClick={(e) => openRow(e, v.vendorId)}
                 onKeyDown={(e) => {
-                  if (e.key === "Enter") router.push(`/dashboard/vendors/${v.vendorId}`)
+                  if (e.key === "Enter") openRow(e, v.vendorId)
                 }}
                 className="flex flex-col gap-3 rounded-xl border bg-card p-4 shadow-sm"
               >
@@ -356,14 +378,15 @@ export default function VendorsPage() {
                 </div>
 
                 <div className="flex items-center justify-end gap-1 border-t pt-3" data-no-row-nav>
-                  <Link
-                    href={`/dashboard/vendors/${v.vendorId}`}
-                    className={cn(buttonVariants({ variant: "ghost", size: "icon-sm" }))}
+                  <Button
+                    variant="ghost"
+                    size="icon-sm"
                     aria-label={`Update ${v.code}`}
                     title="Edit"
+                    onClick={() => setEditingId(v.vendorId)}
                   >
                     <Pencil className="size-4" />
-                  </Link>
+                  </Button>
 
                   <AlertDialog>
                     <AlertDialogTrigger
@@ -373,7 +396,7 @@ export default function VendorsPage() {
                           size="icon-sm"
                           className="text-destructive hover:bg-destructive/10"
                           aria-label={`Delete ${v.code}`}
-                          disabled={v.status === "Inactive" || actionPendingId === v.vendorId}
+                          disabled={actionPendingId === v.vendorId}
                         />
                       }
                     >
@@ -382,9 +405,9 @@ export default function VendorsPage() {
                     <AlertDialogContent
                       variant="destructive"
                       title={`Delete ${v.code}?`}
-                      description={`This deactivates ${v.name} (FR-MD-08 — master data is deactivated, not hard-deleted). It can be reactivated later from its detail page.`}
+                      description={`This permanently deletes ${v.name} and cannot be undone. A vendor used on purchase documents or items can't be deleted — deactivate it from its detail page instead.`}
                       confirmLabel="Delete"
-                      onConfirm={() => handleDeactivate(v)}
+                      onConfirm={() => handleDelete(v)}
                     />
                   </AlertDialog>
                 </div>
@@ -418,10 +441,7 @@ export default function VendorsPage() {
                     <TableRow
                       key={v.vendorId}
                       className="align-top cursor-pointer hover:bg-muted/20"
-                      onClick={(e) => {
-                        if ((e.target as HTMLElement).closest("[data-no-row-nav]")) return
-                        router.push(`/dashboard/vendors/${v.vendorId}`)
-                      }}
+                      onClick={(e) => openRow(e, v.vendorId)}
                     >
                       <TableCell>
                         <Link href={`/dashboard/vendors/${v.vendorId}`} className="font-semibold text-foreground hover:underline">
@@ -457,14 +477,15 @@ export default function VendorsPage() {
                           >
                             <Eye className="size-4" />
                           </Link>
-                          <Link
-                            href={`/dashboard/vendors/${v.vendorId}`}
-                            className={cn(buttonVariants({ variant: "ghost", size: "icon-sm" }))}
+                          <Button
+                            variant="ghost"
+                            size="icon-sm"
                             aria-label={`Update ${v.code}`}
                             title="Edit"
+                            onClick={() => setEditingId(v.vendorId)}
                           >
                             <Pencil className="size-4" />
-                          </Link>
+                          </Button>
 
                           <AlertDialog>
                             <AlertDialogTrigger
@@ -474,7 +495,7 @@ export default function VendorsPage() {
                                   size="icon-sm"
                                   className="text-destructive hover:bg-destructive/10"
                                   aria-label={`Delete ${v.code}`}
-                                  disabled={v.status === "Inactive" || actionPendingId === v.vendorId}
+                                  disabled={actionPendingId === v.vendorId}
                                 />
                               }
                             >
@@ -483,9 +504,9 @@ export default function VendorsPage() {
                             <AlertDialogContent
                               variant="destructive"
                               title={`Delete ${v.code}?`}
-                              description={`This deactivates ${v.name} (FR-MD-08 — master data is deactivated, not hard-deleted). It can be reactivated later from its detail page.`}
+                              description={`This permanently deletes ${v.name} and cannot be undone. A vendor used on purchase documents or items can't be deleted — deactivate it from its detail page instead.`}
                               confirmLabel="Delete"
-                              onConfirm={() => handleDeactivate(v)}
+                              onConfirm={() => handleDelete(v)}
                             />
                           </AlertDialog>
                         </div>
@@ -509,6 +530,22 @@ export default function VendorsPage() {
           )}
         </>
       )}
+
+      {editingId !== null && (
+        <EditVendorDialog
+          key={editingId}
+          vendorId={editingId}
+          existingCodes={allVendorCodes}
+          onClose={() => setEditingId(null)}
+          onSaved={(saved) => {
+            // A renamed vendor gets a regenerated code — swap it so later creates de-dupe correctly.
+            const oldCode = vendors?.find((v) => v.vendorId === saved.vendorId)?.code
+            setAllVendorCodes((codes) => [...codes.filter((c) => c !== oldCode), saved.code])
+            setEditingId(null)
+            load()
+          }}
+        />
+      )}
     </div>
   )
 }
diff --git a/Frontend/erp-system/app/dashboard/warehouse/[id]/page.tsx b/Frontend/erp-system/app/dashboard/warehouse/[id]/page.tsx
index 09919bd..e92dce7 100644
--- a/Frontend/erp-system/app/dashboard/warehouse/[id]/page.tsx
+++ b/Frontend/erp-system/app/dashboard/warehouse/[id]/page.tsx
@@ -10,6 +10,7 @@ import { itemsApi } from "@/lib/api/items"
 import { errorMessage, fieldErrors } from "@/lib/error-map"
 import { Bin, ItemListItem, Warehouse } from "@/types/master-data"
 import { LedgerEntry, OnHand } from "@/types/stock"
+import { useIsMobile } from "@/hooks/use-mobile"
 
 import { useAuth } from "@/components/auth/AuthProvider"
 import { Button } from "@/components/ui/button"
@@ -31,6 +32,8 @@ import BarChart from "@/components/ui/bar-chart"
 
 /** Charts stay legible with a lot of items only by capping to the top N by on-hand qty. */
 const CHART_ROW_LIMIT = 15
+/** Fewest bar slots the charts' axis spans, so a couple of bars sit at the start (see padSlots). */
+const CHART_MIN_SLOTS = 5
 
 const PAGE_SIZE_OPTIONS = [5, 10, 15, 20]
 
@@ -120,8 +123,18 @@ export default function WarehouseDetailPage() {
   const stockRows = useMemo(() => (stock ?? []).slice().sort((a, b) => b.onHand - a.onHand), [stock])
   const totalOnHand = stockRows.reduce((sum, r) => sum + r.onHand, 0)
 
+  // Same fixed-axis padding as the product page's chart: with fewer than CHART_MIN_SLOTS bars,
+  // Chart.js would center them across the full width. Trailing blank slots keep the bars at the
+  // start. Skipped on mobile, where the bars should stretch to fill the narrower card instead.
+  const isMobile = useIsMobile()
+  const padSlots = (count: number) => (isMobile ? 0 : Math.max(0, CHART_MIN_SLOTS - count))
+
   const chartRows = stockRows.slice(0, CHART_ROW_LIMIT)
-  const chartLabels = chartRows.map((r) => itemsById.get(r.itemId)?.sku ?? `#${r.itemId}`)
+  const chartPad = padSlots(chartRows.length)
+  const chartLabels = [
+    ...chartRows.map((r) => itemsById.get(r.itemId)?.sku ?? `#${r.itemId}`),
+    ...Array<string>(chartPad).fill(""),
+  ]
 
   const movementByItem = useMemo(() => {
     const map = new Map<number, { in: number; out: number }>()
@@ -137,12 +150,24 @@ export default function WarehouseDetailPage() {
   }, [ledger])
 
   const movementChartRows = movementByItem.slice(0, CHART_ROW_LIMIT)
-  const movementChartLabels = movementChartRows.map((r) => itemsById.get(r.itemId)?.sku ?? `#${r.itemId}`)
+  const movementChartPad = padSlots(movementChartRows.length)
+  const movementChartLabels = [
+    ...movementChartRows.map((r) => itemsById.get(r.itemId)?.sku ?? `#${r.itemId}`),
+    ...Array<string>(movementChartPad).fill(""),
+  ]
 
   const pagedBins = bins?.slice((binsPage - 1) * binsPageSize, binsPage * binsPageSize) ?? []
   const pagedStockRows = stockRows.slice((stockPage - 1) * stockPageSize, stockPage * stockPageSize)
   const pagedMovementRows = movementByItem.slice((movementPage - 1) * movementPageSize, movementPage * movementPageSize)
 
+  /** Closes the new-bin dialog and clears whatever was typed, so the next open starts blank. */
+  function closeCreate() {
+    setOpen(false)
+    setCode("")
+    setBinType("")
+    setErrors({})
+  }
+
   async function handleCreate() {
     const nextErrors: Record<string, string> = {}
     if (!code.trim()) nextErrors.code = "Bin code is required"
@@ -153,10 +178,7 @@ export default function WarehouseDetailPage() {
     try {
       const bin = await warehousesApi.createBin(warehouseId, { code, binType: binType || null })
       toast.success("Bin created", bin.code)
-      setOpen(false)
-      setCode("")
-      setBinType("")
-      setErrors({})
+      closeCreate()
       loadBins()
     } catch (err) {
       const fe = fieldErrors(err)
@@ -198,7 +220,7 @@ export default function WarehouseDetailPage() {
           )}
         </div>
 
-        <Dialog open={open} onOpenChange={setOpen}>
+        <Dialog open={open} onOpenChange={(v) => (v ? setOpen(true) : closeCreate())}>
           <DialogTrigger
             render={
               <Button size="lg">
@@ -214,8 +236,8 @@ export default function WarehouseDetailPage() {
             </DialogHeader>
             <FieldGroup>
               <Field data-invalid={!!errors.code}>
-                <FieldLabel htmlFor="bin-code">Code</FieldLabel>
-                <Input id="bin-code" value={code} onChange={(e) => setCode(e.target.value)} placeholder="A-01-01" aria-invalid={!!errors.code} />
+                <FieldLabel htmlFor="bin-code" required>Code</FieldLabel>
+                <Input id="bin-code" value={code} onChange={(e) => { setCode(e.target.value); setErrors({}) }} placeholder="A-01-01" aria-invalid={!!errors.code} />
                 <FieldError errors={[errors.code ? { message: errors.code } : undefined]} />
               </Field>
               <Field>
@@ -224,7 +246,7 @@ export default function WarehouseDetailPage() {
               </Field>
             </FieldGroup>
             <div className="flex flex-col-reverse gap-3 pt-2 sm:flex-row sm:justify-center">
-              <Button variant="outline" className="w-full sm:w-auto sm:min-w-36" onClick={() => setOpen(false)} disabled={submitting}>
+              <Button variant="outline" className="w-full sm:w-auto sm:min-w-36" onClick={closeCreate} disabled={submitting}>
                 Cancel
               </Button>
               <Button className="w-full sm:w-auto sm:min-w-36" onClick={handleCreate} disabled={submitting}>
@@ -332,9 +354,18 @@ export default function WarehouseDetailPage() {
               <BarChart
                 labels={chartLabels}
                 datasets={[
-                  { label: "On hand", data: chartRows.map((r) => r.onHand), backgroundColor: "rgba(239,68,68,0.6)" },
-                  { label: "Available", data: chartRows.map((r) => r.available), backgroundColor: "rgba(34,197,94,0.6)" },
+                  {
+                    label: "On hand",
+                    data: [...chartRows.map((r) => r.onHand), ...Array<null>(chartPad).fill(null)],
+                    backgroundColor: "rgba(239,68,68,0.6)",
+                  },
+                  {
+                    label: "Available",
+                    data: [...chartRows.map((r) => r.available), ...Array<null>(chartPad).fill(null)],
+                    backgroundColor: "rgba(34,197,94,0.6)",
+                  },
                 ]}
+                barPercentage={0.6}
               />
             </div>
 
@@ -451,9 +482,18 @@ export default function WarehouseDetailPage() {
               <BarChart
                 labels={movementChartLabels}
                 datasets={[
-                  { label: "In", data: movementChartRows.map((r) => r.in), backgroundColor: "rgba(34,197,94,0.6)" },
-                  { label: "Out", data: movementChartRows.map((r) => r.out), backgroundColor: "rgba(239,68,68,0.6)" },
+                  {
+                    label: "In",
+                    data: [...movementChartRows.map((r) => r.in), ...Array<null>(movementChartPad).fill(null)],
+                    backgroundColor: "rgba(34,197,94,0.6)",
+                  },
+                  {
+                    label: "Out",
+                    data: [...movementChartRows.map((r) => r.out), ...Array<null>(movementChartPad).fill(null)],
+                    backgroundColor: "rgba(239,68,68,0.6)",
+                  },
                 ]}
+                barPercentage={0.6}
               />
             </div>
 
diff --git a/Frontend/erp-system/app/dashboard/warehouse/page.tsx b/Frontend/erp-system/app/dashboard/warehouse/page.tsx
index a9eef3c..721bd5c 100644
--- a/Frontend/erp-system/app/dashboard/warehouse/page.tsx
+++ b/Frontend/erp-system/app/dashboard/warehouse/page.tsx
@@ -126,10 +126,30 @@ export default function WarehousesPage() {
     return () => clearTimeout(t)
   }, [search])
 
+  /** State updater that drops one field's error once the user starts editing that field. */
+  function dropError(key: string) {
+    return (prev: Record<string, string>) => {
+      if (!prev[key]) return prev
+      const next = { ...prev }
+      delete next[key]
+      return next
+    }
+  }
+
   function binCount(warehouseId: number) {
     return (bins ?? []).filter((b) => b.warehouseId === warehouseId).length
   }
 
+  /** Closes the create dialog and clears whatever was typed, so the next open starts blank. */
+  function closeCreate() {
+    setOpen(false)
+    setName("")
+    setAddress("")
+    setPhone("")
+    setBranchId(0)
+    setErrors({})
+  }
+
   async function handleCreate() {
     const nextErrors: Record<string, string> = {}
     if (!name.trim()) nextErrors.name = "Warehouse name is required"
@@ -141,12 +161,7 @@ export default function WarehousesPage() {
     try {
       const warehouse = await warehousesApi.create({ code: generatedCode, name, address: address || null, phone: phone || null, branchId })
       toast.success("Warehouse created", `${warehouse.code} — ${warehouse.name}`)
-      setOpen(false)
-      setName("")
-      setAddress("")
-      setPhone("")
-      setBranchId(0)
-      setErrors({})
+      closeCreate()
       load()
     } catch (err) {
       // A 409 here means another creation raced ours for the same generated code — the
@@ -219,7 +234,7 @@ export default function WarehousesPage() {
           <p className="text-base text-muted-foreground">Multi-warehouse master data with per-warehouse bin/location structure (FR-WH-01, FR-MD-07).</p>
         </div>
 
-        <Dialog open={open} onOpenChange={setOpen}>
+        <Dialog open={open} onOpenChange={(v) => (v ? setOpen(true) : closeCreate())}>
           <DialogTrigger
             render={
               <Button size="lg">
@@ -235,8 +250,8 @@ export default function WarehousesPage() {
             </DialogHeader>
             <FieldGroup>
               <Field data-invalid={!!errors.name}>
-                <FieldLabel htmlFor="wh-name">Name</FieldLabel>
-                <Input id="wh-name" value={name} onChange={(e) => setName(e.target.value)} placeholder="Main Warehouse - Negombo" aria-invalid={!!errors.name} />
+                <FieldLabel htmlFor="wh-name" required>Name</FieldLabel>
+                <Input id="wh-name" value={name} onChange={(e) => { setName(e.target.value); setErrors(dropError("name")) }} placeholder="Main Warehouse - Negombo" aria-invalid={!!errors.name} />
                 <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
               </Field>
               <Field>
@@ -253,8 +268,8 @@ export default function WarehousesPage() {
               </Field>
               {warehouseBranchingEnabled && (
                 <Field data-invalid={!!errors.branchId}>
-                  <FieldLabel htmlFor="wh-branch">Branch</FieldLabel>
-                  <Select value={String(branchId)} onValueChange={(v) => setBranchId(v ? Number(v) : 0)}>
+                  <FieldLabel htmlFor="wh-branch" required>Branch</FieldLabel>
+                  <Select value={String(branchId)} onValueChange={(v) => { setBranchId(v ? Number(v) : 0); setErrors(dropError("branchId")) }}>
                     <SelectTrigger id="wh-branch" aria-invalid={!!errors.branchId}><SelectValue placeholder="Select" /></SelectTrigger>
                     <SelectContent>{branches.map((b) => <SelectItem key={b.branchId} value={String(b.branchId)}>{b.name}</SelectItem>)}</SelectContent>
                   </Select>
@@ -263,7 +278,7 @@ export default function WarehousesPage() {
               )}
             </FieldGroup>
             <div className="flex flex-col-reverse gap-3 pt-2 sm:flex-row sm:justify-center">
-              <Button variant="outline" className="w-full sm:w-auto sm:min-w-36" onClick={() => setOpen(false)} disabled={submitting}>
+              <Button variant="outline" className="w-full sm:w-auto sm:min-w-36" onClick={closeCreate} disabled={submitting}>
                 Cancel
               </Button>
               <Button className="w-full sm:w-auto sm:min-w-36" onClick={handleCreate} disabled={submitting}>
@@ -528,13 +543,13 @@ export default function WarehousesPage() {
           </DialogHeader>
           <FieldGroup>
             <Field data-invalid={!!editErrors.name}>
-              <FieldLabel htmlFor="wh-edit-name">Name</FieldLabel>
-              <Input id="wh-edit-name" value={editName} onChange={(e) => setEditName(e.target.value)} aria-invalid={!!editErrors.name} />
+              <FieldLabel htmlFor="wh-edit-name" required>Name</FieldLabel>
+              <Input id="wh-edit-name" value={editName} onChange={(e) => { setEditName(e.target.value); setEditErrors(dropError("name")) }} aria-invalid={!!editErrors.name} />
               <FieldError errors={[editErrors.name ? { message: editErrors.name } : undefined]} />
             </Field>
             <Field data-invalid={!!editErrors.code}>
-              <FieldLabel htmlFor="wh-edit-code">Code</FieldLabel>
-              <Input id="wh-edit-code" value={editCode} onChange={(e) => setEditCode(e.target.value)} aria-invalid={!!editErrors.code} />
+              <FieldLabel htmlFor="wh-edit-code" required>Code</FieldLabel>
+              <Input id="wh-edit-code" value={editCode} onChange={(e) => { setEditCode(e.target.value); setEditErrors(dropError("code")) }} aria-invalid={!!editErrors.code} />
               <FieldError errors={[editErrors.code ? { message: editErrors.code } : undefined]} />
             </Field>
             <Field>
@@ -547,8 +562,8 @@ export default function WarehousesPage() {
             </Field>
             {warehouseBranchingEnabled && (
               <Field data-invalid={!!editErrors.branchId}>
-                <FieldLabel htmlFor="wh-edit-branch">Branch</FieldLabel>
-                <Select value={String(editBranchId)} onValueChange={(v) => setEditBranchId(v ? Number(v) : 0)}>
+                <FieldLabel htmlFor="wh-edit-branch" required>Branch</FieldLabel>
+                <Select value={String(editBranchId)} onValueChange={(v) => { setEditBranchId(v ? Number(v) : 0); setEditErrors(dropError("branchId")) }}>
                   <SelectTrigger id="wh-edit-branch" aria-invalid={!!editErrors.branchId}><SelectValue placeholder="Select" /></SelectTrigger>
                   <SelectContent>{branches.map((b) => <SelectItem key={b.branchId} value={String(b.branchId)}>{b.name}</SelectItem>)}</SelectContent>
                 </Select>
diff --git a/Frontend/erp-system/app/favicon.ico b/Frontend/erp-system/app/favicon.ico
index 718d6fe..9560350 100644
Binary files a/Frontend/erp-system/app/favicon.ico and b/Frontend/erp-system/app/favicon.ico differ
diff --git a/Frontend/erp-system/app/icon.png b/Frontend/erp-system/app/icon.png
new file mode 100644
index 0000000..017db6a
Binary files /dev/null and b/Frontend/erp-system/app/icon.png differ
diff --git a/Frontend/erp-system/app/layout.tsx b/Frontend/erp-system/app/layout.tsx
index 672a2df..c85a9f9 100644
--- a/Frontend/erp-system/app/layout.tsx
+++ b/Frontend/erp-system/app/layout.tsx
@@ -16,8 +16,8 @@ const geistMono = Geist_Mono({
 });
 
 export const metadata: Metadata = {
-  title: "Create Next App",
-  description: "Generated by create next app",
+  title: "Hexa ERP",
+  description: "Hexa ERP — inventory, procurement, sales and accounting.",
 };
 
 export default function RootLayout({
diff --git a/Frontend/erp-system/components/Layouts/AppSidebar.tsx b/Frontend/erp-system/components/Layouts/AppSidebar.tsx
index 293ae36..879ef52 100644
--- a/Frontend/erp-system/components/Layouts/AppSidebar.tsx
+++ b/Frontend/erp-system/components/Layouts/AppSidebar.tsx
@@ -25,7 +25,10 @@ import {
   HelpCircle,
   IdCard,
   Inbox,
+  ClipboardCheck,
   Landmark,
+  PiggyBank,
+  Tag,
   LayoutGrid,
   LayoutList,
   LayoutTemplate,
@@ -38,17 +41,18 @@ import {
   PackageCheck,
   PackageSearch,
   PackageX,
-  Percent,
   PlayCircle,
   PieChart,
   Receipt,
   ReceiptText,
   Scale,
+  ScanLine,
   ScrollText,
   Settings,
   ShieldCheck,
   ShoppingCart,
   SlidersHorizontal,
+  Tags,
   Truck,
   Undo2,
   Users,
@@ -58,8 +62,12 @@ import {
   type LucideIcon,
 } from "lucide-react"
 
+import { approvalsApi } from "@/lib/api/approvals"
 import { cn } from "@/lib/utils"
 import { useAuth } from "@/components/auth/AuthProvider"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
+
+const SERIALS_HREF = "/dashboard/stock/serials"
 
 // `code` must match the seeded NavItem/SubNavItem codes in ERPCore
 // (Infra/Persistence/Configurations/NavItemConfiguration.cs / SubNavItemConfiguration.cs)
@@ -98,9 +106,11 @@ const navItems: {
         icon: ListTree,
         altCodes: ["products.brand", "products.uom"],
       },
-      { title: "Tax Rates", code: "products.tax-rates", href: "/dashboard/products/tax-rates", icon: Percent },
+      { title: "Price Adjustments", code: "products.price-adjustments", href: "/dashboard/products/price-adjustments", icon: Tag },
     ],
   },
+  // Open to everyone signed in: the inbox only lists what the user may approve and their own requests.
+  { title: "Approvals", code: "approvals", href: "/dashboard/approvals", icon: ClipboardCheck },
   {
     title: "Procurement",
     code: "procurement",
@@ -131,7 +141,8 @@ const navItems: {
       { title: "Customers", code: "sales.invoices", href: "/dashboard/customers", icon: Users },
       { title: "Bundle Templates", code: "sales.bundle-templates", href: "/dashboard/sales/bundles/templates", icon: LayoutList },
       { title: "Free Issues", code: "sales.free-issues", href: "/dashboard/sales/free-issues", icon: PackageX },
-      { title: "Day End", code: "sales.day-end", href: "/dashboard/sales/day-end", icon: Lock },
+      { title: "Approved Invoices", code: "sales.day-end", href: "/dashboard/sales/day-end", icon: Lock },
+      { title: "Day-End Report", code: "sales.day-end-report", href: "/dashboard/sales/day-end-report", icon: LineChart },
       // { title: "Reports", code: "sales.reports", href: "/dashboard/sales/reports", icon: FileBarChart },
     ],
   },
@@ -148,6 +159,9 @@ const navItems: {
     children: [
       { title: "Stock Ledger", code: "stock.ledger", href: "/dashboard/stock/ledger", icon: ScrollText },
       { title: "Stock Enquiry", code: "stock.enquiry", href: "/dashboard/stock/enquiry", icon: PackageSearch },
+      // Serial register and batch expiry are enquiries — they reuse stock.enquiry's permission code.
+      { title: "Serials", code: "stock.enquiry", href: "/dashboard/stock/serials", icon: ScanLine },
+      { title: "Batch Expiry", code: "stock.enquiry", href: "/dashboard/stock/batches", icon: CalendarClock },
       { title: "Valuation", code: "stock.valuation", href: "/dashboard/stock/valuation", icon: BadgeDollarSign },
       { title: "Transfers", code: "stock.transfers", href: "/dashboard/stock/transfers", icon: ArrowLeftRight },
       { title: "Adjustments", code: "stock.adjustments", href: "/dashboard/stock/adjustments", icon: SlidersHorizontal },
@@ -208,6 +222,9 @@ const navItems: {
       { title: "Cash / Bank Accounts", code: "accounts.bank-accounts", href: "/dashboard/accounts/bank-accounts", icon: Wallet },
       { title: "Cheque Books", code: "accounts.cheque-books", href: "/dashboard/accounts/cheque-books", icon: BookText },
       { title: "Received Cheques", code: "accounts.received-cheques", href: "/dashboard/accounts/received-cheques", icon: Inbox },
+      { title: "Expenses", code: "accounts.expenses", href: "/dashboard/accounts/expenses", icon: ReceiptText },
+      { title: "Expense Setup", code: "accounts.expense-setup", href: "/dashboard/accounts/expense-setup", icon: Tags },
+      { title: "Bank Deposits", code: "accounts.bank-deposits", href: "/dashboard/accounts/bank-deposits", icon: PiggyBank },
     ],
   },
   {
@@ -219,6 +236,7 @@ const navItems: {
       { title: "Branches", code: "settings.branches", href: "/dashboard/settings/branches", icon: MapPin },
       { title: "Roles", code: "settings.roles", href: "/dashboard/settings/roles", icon: ShieldCheck },
       { title: "Users", code: "settings.users", href: "/dashboard/settings/users", icon: Users },
+      { title: "Approvals", code: "settings.approvals", href: "/dashboard/settings/approvals", icon: ClipboardCheck },
       { title: "Configuration", code: "products.configuration", href: "/dashboard/settings/configuration", icon: SlidersHorizontal },
     ],
   },
@@ -232,6 +250,7 @@ function SidebarContent({
   onClose,
   pathname,
   isMobile,
+  approvalCount,
 }: {
   items: typeof navItems
   collapsed: boolean
@@ -239,6 +258,8 @@ function SidebarContent({
   onClose?: () => void
   pathname: string
   isMobile: boolean
+  /** Requests the user can approve — the badge on Approvals. */
+  approvalCount: number
 }) {
   const iconOnly = !isMobile && collapsed
 
@@ -360,6 +381,11 @@ function SidebarContent({
                       className={cn("size-3.5 shrink-0", isActive ? "text-primary" : "text-muted-foreground")}
                     />
                     {!iconOnly && <span className="flex-1">{item.title}</span>}
+                    {item.code === "approvals" && approvalCount > 0 && (
+                      <span className="ml-auto rounded-full bg-primary px-1.5 text-[10px] font-semibold leading-4 text-primary-foreground tabular-nums">
+                        {approvalCount}
+                      </span>
+                    )}
                   </Link>
                 )}
               </div>
@@ -427,6 +453,8 @@ export function AppSidebar() {
   const [collapsed, setCollapsed] = useState(false)
   const [mobileOpen, setMobileOpen] = useState(false)
   const { navCodes, loading } = useAuth()
+  // The Serials register is hidden while serial numbers are switched off in Product Configuration.
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   // While /auth/me hasn't resolved yet, show nothing rather than briefly
   // flashing the full menu to a restricted role. Once resolved, a nav item
@@ -440,7 +468,16 @@ export function AppSidebar() {
   // seed grants it. This is also flagged in 02-SECURITY.md as the AR-09 sidebar-visibility
   // stopgap for HRM's salary/PII data — it hides HRM from the UI but doesn't enforce
   // anything server-side.
-  const bypassCodes = new Set(["procurement", "sales", "sales-returns", "hrm", "production", "stock"])
+  // "approvals" is not a permission at all — the inbox is for everyone (see its nav entry).
+  const bypassCodes = new Set(["procurement", "sales", "sales-returns", "hrm", "production", "stock", "approvals"])
+
+  // Requests waiting for this user — the Approvals badge. Refreshed on navigation, which is when
+  // someone has most likely just approved or submitted something.
+  const [approvalCount, setApprovalCount] = useState(0)
+  useEffect(() => {
+    if (loading) return
+    approvalsApi.pending().then((p) => setApprovalCount(p.actionableCount)).catch(() => setApprovalCount(0))
+  }, [loading, pathname])
   const visibleItems = loading
     ? []
     : navItems
@@ -452,9 +489,10 @@ export function AppSidebar() {
         )
         .map((item) => ({
           ...item,
-          children: bypassCodes.has(item.code)
+          children: (bypassCodes.has(item.code)
             ? item.children
-            : item.children?.filter((c) => navCodes.includes(c.code) || c.altCodes?.some((ac) => navCodes.includes(ac))),
+            : item.children?.filter((c) => navCodes.includes(c.code) || c.altCodes?.some((ac) => navCodes.includes(ac)))
+          )?.filter((c) => !(serialNumbersEnabled === false && c.href === SERIALS_HREF)),
         }))
 
   // Close mobile menu on route change
@@ -479,6 +517,7 @@ export function AppSidebar() {
           onCollapse={() => setCollapsed((v) => !v)}
           pathname={pathname}
           isMobile={false}
+          approvalCount={approvalCount}
         />
       </div>
 
@@ -515,6 +554,7 @@ export function AppSidebar() {
           onClose={() => setMobileOpen(false)}
           pathname={pathname}
           isMobile={true}
+          approvalCount={approvalCount}
         />
       </div>
     </>
diff --git a/Frontend/erp-system/components/Layouts/Breadcrumbs.tsx b/Frontend/erp-system/components/Layouts/Breadcrumbs.tsx
index cfd4d4e..5a1e9a6 100644
--- a/Frontend/erp-system/components/Layouts/Breadcrumbs.tsx
+++ b/Frontend/erp-system/components/Layouts/Breadcrumbs.tsx
@@ -30,6 +30,9 @@ const SEGMENT_LABELS: Record<string, string> = {
   counts: "Counts",
   "reorder-alerts": "Reorder Alerts",
   wastage: "Wastage",
+  serials: "Serials",
+  batches: "Batch Expiry",
+  warranties: "Warranties",
   procurement: "Procurement",
   requisitions: "Requisitions",
   rfqs: "RFQs",
diff --git a/Frontend/erp-system/components/Layouts/Header.tsx b/Frontend/erp-system/components/Layouts/Header.tsx
index 8710074..f82e9da 100644
--- a/Frontend/erp-system/components/Layouts/Header.tsx
+++ b/Frontend/erp-system/components/Layouts/Header.tsx
@@ -72,6 +72,9 @@ const ACCOUNTS_TITLES: Record<string, string> = {
   "/dashboard/accounts/cheque-books/new": "New Cheque Book",
   "/dashboard/accounts/received-cheques": "Received Cheques",
   "/dashboard/accounts/received-cheques/new": "New Received Cheque",
+  "/dashboard/accounts/expenses": "Expenses",
+  "/dashboard/accounts/expenses/new": "New Expense",
+  "/dashboard/accounts/expense-setup": "Expense Setup",
 }
 
 const STOCK_TITLES: Record<string, string> = {
@@ -88,6 +91,8 @@ const STOCK_TITLES: Record<string, string> = {
   "/dashboard/stock/reorder-alerts": "Reorder Alerts",
   "/dashboard/stock/wastage": "Wastage",
   "/dashboard/stock/wastage/new": "Record Wastage",
+  "/dashboard/stock/serials": "Serials",
+  "/dashboard/stock/batches": "Batch Expiry",
 }
 
 const PRODUCTION_TITLES: Record<string, string> = {
@@ -101,6 +106,8 @@ const PRODUCTION_TITLES: Record<string, string> = {
 function titleFromPath(pathname: string) {
   if (pathname === "/dashboard/sales/invoices") return "Sales"
   if (pathname === "/dashboard/sales/invoices/new") return "New Sale"
+  if (pathname === "/dashboard/sales/warranties") return "Warranties"
+  if (pathname === "/dashboard/sales/day-end-report") return "Day-End Report"
 
   if (pathname === "/dashboard/receiving/grn") return "Goods Receipt Notes"
   if (pathname === "/dashboard/receiving/grn/new") return "Create Goods Receipt Note"
@@ -110,6 +117,8 @@ function titleFromPath(pathname: string) {
 
   if (ACCOUNTS_TITLES[pathname]) return ACCOUNTS_TITLES[pathname]
   if (/^\/dashboard\/accounts\/cheque-books\/[^/]+$/.test(pathname)) return "Cheque Book"
+  if (/^\/dashboard\/accounts\/expenses\/[^/]+\/edit$/.test(pathname)) return "Edit Expense"
+  if (/^\/dashboard\/accounts\/expenses\/[^/]+$/.test(pathname)) return "Expense"
 
   if (STOCK_TITLES[pathname]) return STOCK_TITLES[pathname]
   if (/^\/dashboard\/stock\/transfers\/[^/]+$/.test(pathname)) return "Stock Transfer"
diff --git a/Frontend/erp-system/components/accounts/ExpenseForm.tsx b/Frontend/erp-system/components/accounts/ExpenseForm.tsx
new file mode 100644
index 0000000..0961597
--- /dev/null
+++ b/Frontend/erp-system/components/accounts/ExpenseForm.tsx
@@ -0,0 +1,438 @@
+"use client"
+
+import { useEffect, useMemo, useState } from "react"
+import Link from "next/link"
+import { Plus } from "lucide-react"
+
+import { expenseSetupApi, expensesApi } from "@/lib/api/expenses"
+import { branchesHrmApi } from "@/lib/api/hrm-masters"
+import { vendorsApi } from "@/lib/api/vendors"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { Branch } from "@/types/hrm"
+import { Vendor } from "@/types/master-data"
+import { CreateExpenseRequest, Expense, ExpenseCategory, ExpenseTitle } from "@/types/expenses"
+
+import { useAuth } from "@/components/auth/AuthProvider"
+import { localToday } from "@/components/sales/PaymentLinesEditor"
+import { Button, buttonVariants } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Textarea } from "@/components/ui/textarea"
+import { toast } from "@/components/ui/toast"
+
+/** What to do once the draft is saved: just keep it, post it, or open the Post & Pay dialog. */
+export type ExpenseSaveAction = "draft" | "post" | "pay"
+
+interface ExpenseFormProps {
+  /** The draft being edited, with its ETag; omitted for a new expense. */
+  existing?: { expense: Expense; etag: string | null }
+  /** Called with the saved (and, for "post", posted) expense. */
+  onSaved: (expense: Expense, action: ExpenseSaveAction) => void
+  cancelHref: string
+}
+
+type Errors = Partial<Record<"expenseDate" | "dueDate" | "categoryId" | "titleId" | "amount" | "periodMonth", string>>
+
+/** Create/edit form for a Draft expense: Category → Title (filtered), payee/vendor, amount, dates. */
+export function ExpenseForm({ existing, onSaved, cancelHref }: ExpenseFormProps) {
+  const { isAdmin, loading: authLoading, navCodes, branchId: myBranchId, activeBranchId, activeBranchName, branchingEnabled } = useAuth()
+  const initial = existing?.expense
+
+  const [categories, setCategories] = useState<ExpenseCategory[] | null>(null)
+  const [vendors, setVendors] = useState<Vendor[]>([])
+  const [branches, setBranches] = useState<Branch[]>([])
+  const [loadError, setLoadError] = useState<string | null>(null)
+
+  const [branchPickId, setBranchPickId] = useState<number | null>(initial?.branchId ?? null)
+  const [expenseDate, setExpenseDate] = useState(initial?.expenseDate ?? localToday())
+  const [dueDate, setDueDate] = useState(initial?.dueDate ?? "")
+  const [categoryId, setCategoryId] = useState<number | null>(initial?.expenseCategoryId ?? null)
+  const [titleId, setTitleId] = useState<number | null>(initial?.expenseTitleId ?? null)
+  const [vendorId, setVendorId] = useState<number | null>(initial?.vendorId ?? null)
+  const [payee, setPayee] = useState(initial?.payee ?? "")
+  const [billReference, setBillReference] = useState(initial?.billReference ?? "")
+  const [periodMonth, setPeriodMonth] = useState(initial?.periodMonth ?? "")
+  const [amount, setAmount] = useState(initial ? initial.amount.toFixed(2) : "")
+  const [description, setDescription] = useState(initial?.description ?? "")
+
+  const [errors, setErrors] = useState<Errors>({})
+  const [submitError, setSubmitError] = useState<string | null>(null)
+  const [saving, setSaving] = useState<ExpenseSaveAction | null>(null)
+  const [addTitleOpen, setAddTitleOpen] = useState(false)
+
+  const canAddTitle = isAdmin || navCodes.includes("accounts.expense-setup")
+
+  useEffect(() => {
+    expenseSetupApi
+      .list()
+      .then(setCategories)
+      .catch((err) => setLoadError(errorMessage(err)))
+    vendorsApi.list({ pageSize: 200 }).then((r) => setVendors(r.items)).catch(() => setVendors([]))
+  }, [])
+
+  useEffect(() => {
+    if (branchingEnabled && isAdmin) branchesHrmApi.list({ pageSize: 200, status: "Active" }).then((r) => setBranches(r.items)).catch(() => setBranches([]))
+  }, [branchingEnabled, isAdmin])
+
+  const category = categories?.find((c) => c.expenseCategoryId === categoryId) ?? null
+  const titles: ExpenseTitle[] = useMemo(() => category?.titles ?? [], [category])
+
+  // A draft whose category/title has since been deactivated still shows it, so the user can see what to change.
+  const inactiveSelection = !!initial && categories !== null && categoryId !== null && !titles.some((t) => t.expenseTitleId === titleId)
+
+  const lockedBranchId = isAdmin ? activeBranchId : myBranchId
+  const showBranchPicker = branchingEnabled && isAdmin && !lockedBranchId
+  const effectiveBranchId = branchingEnabled ? (isAdmin ? (activeBranchId ?? branchPickId) : myBranchId) : null
+
+  function validate(): Errors {
+    const next: Errors = {}
+    const value = Number(amount)
+    if (!expenseDate) next.expenseDate = "Select the expense date"
+    else if (expenseDate > localToday()) next.expenseDate = "Expense date cannot be in the future"
+    if (dueDate && expenseDate && dueDate < expenseDate) next.dueDate = "Due date cannot be before the expense date"
+    if (!categoryId) next.categoryId = "Select a category"
+    if (!titleId) next.titleId = "Select a title"
+    else if (inactiveSelection) next.titleId = "This title is inactive — pick another"
+    if (!amount || Number.isNaN(value) || value <= 0) next.amount = "Enter an amount greater than zero"
+    if (periodMonth && !/^\d{4}-(0[1-9]|1[0-2])$/.test(periodMonth)) next.periodMonth = "Use the month picker"
+    return next
+  }
+
+  async function save(action: ExpenseSaveAction) {
+    setSubmitError(null)
+    const nextErrors = validate()
+    setErrors(nextErrors)
+    if (Object.keys(nextErrors).length > 0) return
+
+    const request: CreateExpenseRequest = {
+      branchId: effectiveBranchId ?? 0,
+      expenseDate,
+      dueDate: dueDate || null,
+      expenseCategoryId: categoryId!,
+      expenseTitleId: titleId!,
+      vendorId,
+      payee: payee.trim() || null,
+      billReference: billReference.trim() || null,
+      description: description.trim() || null,
+      periodMonth: periodMonth || null,
+      amount: Number(amount),
+    }
+
+    setSaving(action)
+    let saved: Expense
+    try {
+      saved = existing
+        ? (await expensesApi.update(existing.expense.expenseId, request, existing.etag ?? "")).data
+        : (await expensesApi.create(request)).data
+    } catch (err) {
+      setSubmitError(errorMessage(err))
+      toast.error("Could not save expense", errorMessage(err))
+      setSaving(null)
+      return
+    }
+
+    if (action === "post") {
+      try {
+        saved = await expensesApi.post(saved.expenseId)
+        toast.success("Expense posted", `${saved.docNo} — journal ${saved.glJournalNo ?? "—"}`)
+      } catch (err) {
+        // The draft is saved either way; say so, then carry on to it.
+        toast.error(`${saved.docNo} was saved as a draft, but could not be posted`, errorMessage(err))
+      }
+    } else if (action === "draft") {
+      toast.success("Expense saved", `${saved.docNo} is a draft — post it when ready.`)
+    }
+    setSaving(null)
+    onSaved(saved, action)
+  }
+
+  if (loadError) return <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{loadError}</div>
+  if (categories === null || authLoading) return <Skeleton className="h-96 w-full" />
+
+  return (
+    <div className="flex flex-col gap-6">
+      <div className="rounded-2xl border bg-card p-4 shadow-sm sm:p-6">
+        <FieldGroup>
+          {branchingEnabled && isAdmin && !existing && (
+            <Field className="sm:max-w-xs">
+              <FieldLabel>Branch</FieldLabel>
+              {showBranchPicker ? (
+                <Select<number | null> value={branchPickId} onValueChange={(v) => setBranchPickId(v)}>
+                  <SelectTrigger className="h-11! w-full text-base">
+                    <SelectValue placeholder="Default branch" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {branches.map((b) => (
+                      <SelectItem key={b.branchId} value={b.branchId} className="text-base">
+                        {b.name}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              ) : (
+                <div className="flex h-11 items-center rounded-lg border border-input bg-muted px-3 text-base text-muted-foreground">
+                  {activeBranchName ?? `Branch #${lockedBranchId}`}
+                </div>
+              )}
+            </Field>
+          )}
+
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+            <Field data-invalid={!!errors.categoryId}>
+              <FieldLabel htmlFor="exp-category" required>Category</FieldLabel>
+              <Select<number | null>
+                value={categoryId}
+                onValueChange={(v) => {
+                  setCategoryId(v)
+                  setTitleId(null)
+                }}
+              >
+                <SelectTrigger id="exp-category" className="h-11! w-full text-base" aria-invalid={!!errors.categoryId}>
+                  <SelectValue placeholder={inactiveSelection ? initial?.categoryName : "Select category"} />
+                </SelectTrigger>
+                <SelectContent>
+                  {categories.map((c) => (
+                    <SelectItem key={c.expenseCategoryId} value={c.expenseCategoryId} className="text-base">
+                      {c.name}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <FieldError errors={[errors.categoryId ? { message: errors.categoryId } : undefined]} />
+            </Field>
+
+            <Field data-invalid={!!errors.titleId}>
+              <div className="flex items-center justify-between gap-2">
+                <FieldLabel htmlFor="exp-title" required>Title</FieldLabel>
+                {canAddTitle && category && (
+                  <button type="button" className="inline-flex items-center gap-1 text-sm font-medium text-primary hover:underline" onClick={() => setAddTitleOpen(true)}>
+                    <Plus className="size-3.5" />
+                    Add title
+                  </button>
+                )}
+              </div>
+              <Select<number | null> value={titleId} onValueChange={(v) => setTitleId(v)} disabled={!category}>
+                <SelectTrigger id="exp-title" className="h-11! w-full text-base" aria-invalid={!!errors.titleId}>
+                  <SelectValue placeholder={inactiveSelection ? initial?.titleName : category ? "Select title" : "Pick a category first"} />
+                </SelectTrigger>
+                <SelectContent>
+                  {titles.map((t) => (
+                    <SelectItem key={t.expenseTitleId} value={t.expenseTitleId} className="text-base">
+                      {t.name}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <FieldError errors={[errors.titleId ? { message: errors.titleId } : undefined]} />
+            </Field>
+          </div>
+
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-3">
+            <Field data-invalid={!!errors.amount}>
+              <FieldLabel htmlFor="exp-amount" required>Amount</FieldLabel>
+              <Input
+                id="exp-amount"
+                type="number"
+                min="0"
+                step="0.01"
+                inputMode="decimal"
+                value={amount}
+                onChange={(e) => setAmount(e.target.value)}
+                aria-invalid={!!errors.amount}
+                className="h-11 text-base tabular-nums"
+              />
+              <FieldError errors={[errors.amount ? { message: errors.amount } : undefined]} />
+            </Field>
+            <Field data-invalid={!!errors.expenseDate}>
+              <FieldLabel htmlFor="exp-date" required>Bill date</FieldLabel>
+              <Input
+                id="exp-date"
+                type="date"
+                max={localToday()}
+                value={expenseDate}
+                onChange={(e) => setExpenseDate(e.target.value)}
+                aria-invalid={!!errors.expenseDate}
+                className="h-11 text-base"
+              />
+              <FieldError errors={[errors.expenseDate ? { message: errors.expenseDate } : undefined]} />
+            </Field>
+            <Field data-invalid={!!errors.dueDate}>
+              <FieldLabel htmlFor="exp-due">Due date</FieldLabel>
+              <Input
+                id="exp-due"
+                type="date"
+                min={expenseDate || undefined}
+                value={dueDate}
+                onChange={(e) => setDueDate(e.target.value)}
+                aria-invalid={!!errors.dueDate}
+                className="h-11 text-base"
+              />
+              <FieldError errors={[errors.dueDate ? { message: errors.dueDate } : undefined]} />
+            </Field>
+          </div>
+
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-3">
+            <Field>
+              <FieldLabel htmlFor="exp-vendor">Vendor (optional)</FieldLabel>
+              <Select<number | null> value={vendorId} onValueChange={(v) => setVendorId(v)}>
+                <SelectTrigger id="exp-vendor" className="h-11! w-full text-base">
+                  <SelectValue placeholder="No vendor" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value={null} className="text-base">No vendor</SelectItem>
+                  {vendors.map((v) => (
+                    <SelectItem key={v.vendorId} value={v.vendorId} className="text-base">
+                      {v.name}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </Field>
+            <Field>
+              <FieldLabel htmlFor="exp-payee">Payee</FieldLabel>
+              <Input
+                id="exp-payee"
+                value={payee}
+                maxLength={150}
+                placeholder={vendorId ? "Defaults to the vendor" : "e.g. CEB, landlord"}
+                onChange={(e) => setPayee(e.target.value)}
+                className="h-11 text-base"
+              />
+            </Field>
+            <Field>
+              <FieldLabel htmlFor="exp-ref">Bill / account ref</FieldLabel>
+              <Input id="exp-ref" value={billReference} maxLength={50} onChange={(e) => setBillReference(e.target.value)} className="h-11 text-base" />
+            </Field>
+          </div>
+
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-3">
+            <Field data-invalid={!!errors.periodMonth}>
+              <FieldLabel htmlFor="exp-period">Period covered</FieldLabel>
+              <Input
+                id="exp-period"
+                type="month"
+                value={periodMonth}
+                onChange={(e) => setPeriodMonth(e.target.value)}
+                aria-invalid={!!errors.periodMonth}
+                className="h-11 text-base"
+              />
+              <FieldError errors={[errors.periodMonth ? { message: errors.periodMonth } : undefined]} />
+            </Field>
+            <Field className="sm:col-span-2">
+              <FieldLabel htmlFor="exp-desc">Description</FieldLabel>
+              <Textarea id="exp-desc" value={description} maxLength={500} rows={2} onChange={(e) => setDescription(e.target.value)} className="text-base" />
+            </Field>
+          </div>
+        </FieldGroup>
+      </div>
+
+      {submitError && <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-4 text-base text-destructive">{submitError}</div>}
+
+      <div className="flex flex-col-reverse gap-3 sm:flex-row sm:justify-end">
+        <Link href={cancelHref} className={cn(buttonVariants({ variant: "outline", size: "lg" }))}>
+          Cancel
+        </Link>
+        <Button size="lg" variant="outline" onClick={() => save("draft")} disabled={saving !== null}>
+          {saving === "draft" ? "Saving…" : "Save draft"}
+        </Button>
+        <Button size="lg" variant="outline" onClick={() => save("post")} disabled={saving !== null}>
+          {saving === "post" ? "Posting…" : "Save & post"}
+        </Button>
+        <Button size="lg" onClick={() => save("pay")} disabled={saving !== null}>
+          {saving === "pay" ? "Saving…" : "Save & pay"}
+        </Button>
+      </div>
+
+      {category && (
+        <AddTitleDialog
+          open={addTitleOpen}
+          onOpenChange={setAddTitleOpen}
+          category={category}
+          onCreated={(title) => {
+            setCategories((prev) =>
+              prev?.map((c) => (c.expenseCategoryId === title.expenseCategoryId ? { ...c, titles: [...c.titles, title] } : c)) ?? prev
+            )
+            setTitleId(title.expenseTitleId)
+          }}
+        />
+      )}
+    </div>
+  )
+}
+
+/** Quick-add a custom title under the chosen category, defaulting its GL code to the category's first title's. */
+export function AddTitleDialog({
+  open,
+  onOpenChange,
+  category,
+  onCreated,
+}: {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  category: ExpenseCategory
+  onCreated: (title: ExpenseTitle) => void
+}) {
+  const [name, setName] = useState("")
+  const [glCode, setGlCode] = useState("")
+  const [error, setError] = useState<string | null>(null)
+  const [saving, setSaving] = useState(false)
+
+  const openKey = open ? category.expenseCategoryId : null
+  const [resetFor, setResetFor] = useState<number | null>(null)
+  if (openKey !== null && resetFor !== openKey) {
+    setResetFor(openKey)
+    setName("")
+    setGlCode(category.titles[0]?.glExpenseAccountCode ?? "")
+    setError(null)
+  }
+  if (!open && resetFor !== null) setResetFor(null)
+
+  async function submit() {
+    if (!name.trim()) return setError("Enter a title name")
+    if (!glCode.trim()) return setError("Enter the GL expense account code")
+    setSaving(true)
+    try {
+      const title = await expenseSetupApi.createTitle(category.expenseCategoryId, { name: name.trim(), glExpenseAccountCode: glCode.trim() })
+      toast.success("Title added", `${title.name} under ${category.name}`)
+      onCreated(title)
+      onOpenChange(false)
+    } catch (err) {
+      setError(errorMessage(err))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>Add title to {category.name}</DialogTitle>
+        </DialogHeader>
+        <FieldGroup>
+          <Field>
+            <FieldLabel htmlFor="new-title-name" required>Title</FieldLabel>
+            <Input id="new-title-name" value={name} maxLength={100} autoFocus onChange={(e) => setName(e.target.value)} />
+          </Field>
+          <Field>
+            <FieldLabel htmlFor="new-title-gl" required>GL expense account code</FieldLabel>
+            <Input id="new-title-gl" value={glCode} maxLength={20} onChange={(e) => setGlCode(e.target.value)} />
+          </Field>
+          {error && <p className="text-sm text-destructive">{error}</p>}
+        </FieldGroup>
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)} disabled={saving}>
+            Cancel
+          </Button>
+          <Button onClick={submit} disabled={saving}>
+            {saving ? "Adding…" : "Add title"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/Frontend/erp-system/components/accounts/ExpensePaymentDialog.tsx b/Frontend/erp-system/components/accounts/ExpensePaymentDialog.tsx
new file mode 100644
index 0000000..defa3ad
--- /dev/null
+++ b/Frontend/erp-system/components/accounts/ExpensePaymentDialog.tsx
@@ -0,0 +1,234 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+import { bankAccountsApi } from "@/lib/api/general-ledger"
+import { expensesApi } from "@/lib/api/expenses"
+import { errorMessage } from "@/lib/error-map"
+import { formatAmount } from "@/lib/format"
+import { CashAndBankAccountDto } from "@/types/general-ledger"
+import { Expense, ExpensePaymentMethod, ExpenseSummary, expensePaymentMethodLabels } from "@/types/expenses"
+
+import { Button } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { toast } from "@/components/ui/toast"
+import {
+  localToday,
+  PaymentLine,
+  PaymentLinesEditor,
+  round2,
+  validatePaymentLines,
+} from "@/components/sales/PaymentLinesEditor"
+
+interface ExpensePaymentDialogProps {
+  // ExpenseSummary is enough (id/docNo/status/amount/balance), so a list row can open it directly.
+  expense: ExpenseSummary | null
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  /** Called after a successful submit; the caller reloads whatever it shows. */
+  onDone: (updated: Expense | null) => void
+}
+
+const methods = Object.keys(expensePaymentMethodLabels) as ExpensePaymentMethod[]
+
+/** Pay an expense, in full or partially — split across one or more GL cash/bank accounts, posted as
+ * one GL entry. A Draft expense is posted and paid in a single server transaction (Post & Pay), so a
+ * failure never leaves it half-done; any unpaid remainder stays as the balance for a later payment. */
+export function ExpensePaymentDialog({ expense, open, onOpenChange, onDone }: ExpensePaymentDialogProps) {
+  const [accounts, setAccounts] = useState<CashAndBankAccountDto[] | null>(null)
+  // The list comes from the external GL service, which can be slow or fail; keep the error so the
+  // user sees why the list is empty and can retry, instead of a silently blank dropdown.
+  const [accountsError, setAccountsError] = useState<string | null>(null)
+  const [lines, setLines] = useState<PaymentLine[]>([])
+  const [method, setMethod] = useState<ExpensePaymentMethod>("Cash")
+  const [chequeNo, setChequeNo] = useState("")
+  const [reference, setReference] = useState("")
+  const [paymentDate, setPaymentDate] = useState(localToday)
+  const [errors, setErrors] = useState<Record<string, string>>({})
+  const [submitting, setSubmitting] = useState(false)
+
+  // Reset for a fresh open (or a different expense) during render — the same "adjust state while
+  // rendering" pattern as PurchaseInvoicePaymentDialog.
+  const openKey = open && expense ? `${expense.expenseId}` : null
+  const [resetFor, setResetFor] = useState<string | null>(null)
+  if (openKey !== null && resetFor !== openKey) {
+    setResetFor(openKey)
+    setLines([{ key: 0, glBankAccountId: "", amount: expense!.balanceAmount.toFixed(2) }])
+    setMethod("Cash")
+    setChequeNo("")
+    setReference("")
+    setPaymentDate(localToday())
+    setErrors({})
+    // A failed load is retried on the next open rather than cached as an empty list.
+    if (accountsError) {
+      setAccounts(null)
+      setAccountsError(null)
+    }
+  }
+  if (!open && resetFor !== null) setResetFor(null)
+
+  useEffect(() => {
+    if (!open || accounts !== null) return
+    bankAccountsApi
+      .list("Both")
+      .then((rows) => {
+        setAccounts(rows)
+        setAccountsError(null)
+      })
+      .catch((err) => {
+        setAccounts([])
+        setAccountsError(errorMessage(err))
+      })
+  }, [open, accounts])
+
+  function retryAccounts() {
+    setAccounts(null)
+    setAccountsError(null)
+  }
+
+  if (!expense) return null
+
+  const isDraft = expense.status === "Draft"
+  const balance = expense.balanceAmount
+
+  async function submit() {
+    if (!expense) return
+    const nextErrors = validatePaymentLines(lines, balance)
+    if (!paymentDate) nextErrors.paymentDate = "Select the payment date"
+    else if (paymentDate > localToday()) nextErrors.paymentDate = "Payment date cannot be in the future"
+    if (method === "Cheque" && !chequeNo.trim()) nextErrors.chequeNo = "Enter the cheque number"
+    setErrors(nextErrors)
+    if (Object.keys(nextErrors).length > 0) return
+
+    const request = {
+      lines: lines.map((l) => ({ glBankAccountId: Number(l.glBankAccountId), amount: Number(l.amount) })),
+      paymentMethod: method,
+      chequeNo: method === "Cheque" ? chequeNo.trim() : undefined,
+      reference: reference.trim() || undefined,
+      paymentDate,
+    }
+
+    setSubmitting(true)
+    try {
+      if (isDraft) {
+        const updated = await expensesApi.postAndPay(expense.expenseId, request)
+        toast.success(
+          "Expense posted and paid",
+          `${updated.docNo} — ${formatAmount(updated.paidAmount)} paid${updated.balanceAmount > 0 ? `, ${formatAmount(updated.balanceAmount)} still due` : " in full"}.`
+        )
+        onDone(updated)
+      } else {
+        const rows = await expensesApi.pay(expense.expenseId, request)
+        const paid = round2(rows.reduce((sum, r) => sum + r.amount, 0))
+        toast.success(
+          "Payment recorded",
+          `${formatAmount(paid)} posted to the ledger (${rows[0]?.glJournalNo ?? "—"}) — ${paid >= balance ? "fully paid" : "partially paid"}.`
+        )
+        onDone(null)
+      }
+      onOpenChange(false)
+    } catch (err) {
+      toast.error(isDraft ? "Could not post and pay the expense" : "Could not record payment", errorMessage(err))
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-xl">
+        <DialogHeader>
+          <DialogTitle>{isDraft ? "Post & pay" : "Pay"} expense {expense.docNo}</DialogTitle>
+        </DialogHeader>
+
+        <p className="text-sm text-muted-foreground">
+          {isDraft && "This expense is still a draft — it will be posted and paid in one step. "}
+          Pay the full balance or change the amount to pay part of it now.{" "}
+          {expense.categoryName} · {expense.titleName} — balance due:{" "}
+          <span className="font-medium text-foreground tabular-nums">{formatAmount(balance)}</span>
+        </p>
+
+        <FieldGroup>
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+            <Field data-invalid={!!errors.paymentDate}>
+              <FieldLabel htmlFor="exp-pay-date" required>Payment date</FieldLabel>
+              <Input
+                id="exp-pay-date"
+                type="date"
+                max={localToday()}
+                value={paymentDate}
+                onChange={(e) => setPaymentDate(e.target.value)}
+                aria-invalid={!!errors.paymentDate}
+              />
+              <FieldError errors={[errors.paymentDate ? { message: errors.paymentDate } : undefined]} />
+            </Field>
+
+            <Field>
+              <FieldLabel htmlFor="exp-pay-method" required>Payment method</FieldLabel>
+              <Select<ExpensePaymentMethod> value={method} onValueChange={(v) => v && setMethod(v)}>
+                <SelectTrigger id="exp-pay-method" className="w-full text-base">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {methods.map((m) => (
+                    <SelectItem key={m} value={m} className="text-base">
+                      {expensePaymentMethodLabels[m]}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </Field>
+          </div>
+
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+            {method === "Cheque" && (
+              <Field data-invalid={!!errors.chequeNo}>
+                <FieldLabel htmlFor="exp-pay-cheque" required>Cheque no.</FieldLabel>
+                <Input
+                  id="exp-pay-cheque"
+                  value={chequeNo}
+                  maxLength={30}
+                  onChange={(e) => setChequeNo(e.target.value)}
+                  aria-invalid={!!errors.chequeNo}
+                />
+                <FieldError errors={[errors.chequeNo ? { message: errors.chequeNo } : undefined]} />
+              </Field>
+            )}
+            <Field>
+              <FieldLabel htmlFor="exp-pay-reference">Reference (optional)</FieldLabel>
+              <Input id="exp-pay-reference" value={reference} maxLength={100} onChange={(e) => setReference(e.target.value)} />
+            </Field>
+          </div>
+
+          {accountsError && (
+            <div className="flex items-center justify-between gap-3 rounded-lg border border-destructive/30 bg-destructive/5 p-3 text-sm text-destructive">
+              <span>Could not load cash/bank accounts from the ledger: {accountsError}</span>
+              <Button type="button" size="sm" variant="outline" onClick={retryAccounts}>
+                Retry
+              </Button>
+            </div>
+          )}
+          {accounts !== null && accounts.length === 0 && !accountsError && (
+            <p className="text-sm text-muted-foreground">
+              No cash/bank accounts exist in the ledger yet — add one under Accounts → Cash / Bank Accounts.
+            </p>
+          )}
+
+          <PaymentLinesEditor lines={lines} onChange={setLines} accounts={accounts} balance={balance} errors={errors} />
+        </FieldGroup>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)} disabled={submitting}>
+            Cancel
+          </Button>
+          <Button onClick={submit} disabled={submitting}>
+            {submitting ? "Recording…" : isDraft ? "Post & record payment" : "Record payment"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/Frontend/erp-system/components/accounts/bank-deposit-badges.tsx b/Frontend/erp-system/components/accounts/bank-deposit-badges.tsx
new file mode 100644
index 0000000..d76837e
--- /dev/null
+++ b/Frontend/erp-system/components/accounts/bank-deposit-badges.tsx
@@ -0,0 +1,14 @@
+import { Badge } from "@/components/ui/badge"
+import { BankDepositStatus } from "@/types/bank-deposits"
+
+// Same fixed-width pill as expense-badges.tsx.
+const badgeSize = "h-6 w-28 justify-center px-2.5 py-1 text-sm"
+
+export function BankDepositStatusBadge({ status }: { status: BankDepositStatus }) {
+  const tone = status === "Posted" ? "bg-success/10 text-success" : "bg-muted text-muted-foreground"
+  return (
+    <Badge variant="outline" className={`${badgeSize} border-transparent ${tone}`}>
+      {status}
+    </Badge>
+  )
+}
diff --git a/Frontend/erp-system/components/accounts/expense-badges.tsx b/Frontend/erp-system/components/accounts/expense-badges.tsx
new file mode 100644
index 0000000..270d5e0
--- /dev/null
+++ b/Frontend/erp-system/components/accounts/expense-badges.tsx
@@ -0,0 +1,44 @@
+import { Badge } from "@/components/ui/badge"
+import { ExpensePaymentStatus, ExpenseStatus } from "@/types/expenses"
+
+// Fixed width so every pill lines up — same convention as components/procurement/status-badges.tsx.
+const badgeSize = "h-6 w-32 justify-center px-2.5 py-1 text-sm"
+
+function statusClass(status: ExpenseStatus) {
+  if (status === "Draft") return "bg-warning/10 text-warning border-transparent"
+  if (status === "Posted") return "bg-success/10 text-success border-transparent"
+  return "bg-muted text-muted-foreground border-transparent" // Cancelled
+}
+
+export function ExpenseStatusBadge({ status }: { status: ExpenseStatus }) {
+  return (
+    <Badge variant="outline" className={`${badgeSize} ${statusClass(status)}`}>
+      {status}
+    </Badge>
+  )
+}
+
+function paymentClass(status: ExpensePaymentStatus) {
+  if (status === "Paid") return "bg-success/10 text-success border-transparent"
+  if (status === "PartiallyPaid") return "bg-warning/10 text-warning border-transparent"
+  return "bg-destructive/10 text-destructive border-transparent" // Unpaid
+}
+
+const paymentLabel: Record<ExpensePaymentStatus, string> = {
+  Unpaid: "Unpaid",
+  PartiallyPaid: "Partially paid",
+  Paid: "Paid",
+}
+
+export function ExpensePaymentStatusBadge({ status }: { status: ExpensePaymentStatus }) {
+  return (
+    <Badge variant="outline" className={`${badgeSize} ${paymentClass(status)}`}>
+      {paymentLabel[status]}
+    </Badge>
+  )
+}
+
+/** Posted with a balance and a due date already passed (compared as local `YYYY-MM-DD`). */
+export function isExpenseOverdue(e: { status: ExpenseStatus; balanceAmount: number; dueDate: string | null }, today: string): boolean {
+  return e.status === "Posted" && e.balanceAmount > 0 && e.dueDate !== null && e.dueDate < today
+}
diff --git a/Frontend/erp-system/components/approvals/ApprovalPanel.tsx b/Frontend/erp-system/components/approvals/ApprovalPanel.tsx
new file mode 100644
index 0000000..6686253
--- /dev/null
+++ b/Frontend/erp-system/components/approvals/ApprovalPanel.tsx
@@ -0,0 +1,240 @@
+"use client"
+
+import { useState } from "react"
+import { Check, CircleDashed, ShieldCheck, Undo2, X } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+import { ApprovalStep, PriceAdjustmentStatus } from "@/types/approvals"
+
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldLabel } from "@/components/ui/field"
+import { Textarea } from "@/components/ui/textarea"
+
+interface ApprovalPanelProps {
+  /** "stock adjustment" / "price adjustment" — used in the wording. */
+  what: string
+  requiredApprovals: number
+  /** The approval it waits for (1 or 2); null when it's no longer pending. */
+  pendingLevel: number | null
+  history: ApprovalStep[]
+  requestedByLabel: string
+  requestedAt: string
+  canApprove: boolean
+  whyNot: string | null
+  canWithdraw: boolean
+  /** What happens on the final approval, e.g. "Stock moves and the ledger is posted." */
+  finalEffect: string
+  outcome: "pending" | "applied" | "rejected" | "withdrawn"
+  outcomeAt?: string | null
+  rejectReason?: string | null
+  onApprove: (comment: string | undefined) => Promise<void>
+  onReject: (reason: string) => Promise<void>
+  onWithdraw: () => Promise<void>
+}
+
+/**
+ * The approval trail and the actions for the current user (docs/DUAL_APPROVAL_PLAN.md §10): who
+ * requested it, each level's decision, and Approve / Reject / Withdraw when the user may.
+ */
+export function ApprovalPanel(props: ApprovalPanelProps) {
+  const { what, requiredApprovals, pendingLevel, history, canApprove, whyNot, canWithdraw, outcome } = props
+  const [busy, setBusy] = useState<"approve" | "reject" | "withdraw" | null>(null)
+  const [comment, setComment] = useState("")
+  const [rejectOpen, setRejectOpen] = useState(false)
+  const [reason, setReason] = useState("")
+  const [reasonError, setReasonError] = useState<string | null>(null)
+
+  const isFinal = pendingLevel !== null && pendingLevel >= requiredApprovals
+  const levels = Array.from({ length: requiredApprovals }, (_, i) => i + 1)
+
+  async function run(kind: "approve" | "withdraw", action: () => Promise<void>) {
+    setBusy(kind)
+    try {
+      await action()
+      setComment("")
+    } catch {
+      // The caller has already shown the error.
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  async function reject() {
+    if (!reason.trim()) {
+      setReasonError("Give a reason")
+      return
+    }
+    setBusy("reject")
+    try {
+      await props.onReject(reason.trim())
+      setRejectOpen(false)
+      setReason("")
+    } catch {
+      // The caller has already shown the error; keep the dialog open to retry.
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  if (requiredApprovals === 0) {
+    return (
+      <div className="flex items-center gap-2 rounded-xl border bg-card p-4 text-sm text-muted-foreground shadow-sm">
+        <ShieldCheck className="size-4" />
+        Applied without approval (approvals were switched off when it was made).
+      </div>
+    )
+  }
+
+  return (
+    <div className="flex flex-col gap-4 rounded-xl border bg-card p-4 shadow-sm sm:p-5">
+      <div className="flex items-center justify-between gap-3">
+        <h2 className="text-base font-semibold text-foreground">Approval</h2>
+        <Badge variant="outline" className="border-transparent bg-muted text-xs">
+          {requiredApprovals === 2 ? "Two approvals required" : "One approval required"}
+        </Badge>
+      </div>
+
+      <ol className="flex flex-col gap-3">
+        <Step
+          state="done"
+          title={`Requested by ${props.requestedByLabel}`}
+          detail={new Date(props.requestedAt).toLocaleString()}
+        />
+        {levels.map((level) => {
+          const step = history.find((s) => s.level === level)
+          if (step) {
+            return (
+              <Step
+                key={level}
+                state={step.decision === "Approved" ? "done" : "rejected"}
+                title={`${step.decision === "Approved" ? "Approved" : "Rejected"} (${ordinal(level)} approval) by ${step.decidedByName ?? `#${step.decidedBy}`}`}
+                detail={`${new Date(step.decidedAt).toLocaleString()}${step.comment ? ` — “${step.comment}”` : ""}`}
+              />
+            )
+          }
+          const waiting = outcome === "pending" && pendingLevel === level
+          return (
+            <Step
+              key={level}
+              state={waiting ? "waiting" : "idle"}
+              title={`${ordinal(level)} approval`}
+              detail={waiting ? (level === 2 ? "Waiting — must be a different person from the first approver" : "Waiting for an approver") : "—"}
+            />
+          )
+        })}
+      </ol>
+
+      {outcome === "rejected" && props.rejectReason && (
+        <p className="rounded-lg bg-destructive/10 p-3 text-sm text-destructive">Rejected: {props.rejectReason}</p>
+      )}
+      {outcome === "applied" && (
+        <p className="rounded-lg bg-success/10 p-3 text-sm text-success">
+          Fully approved{props.outcomeAt ? ` and applied ${new Date(props.outcomeAt).toLocaleString()}` : ""}.
+        </p>
+      )}
+      {outcome === "withdrawn" && <p className="rounded-lg bg-muted p-3 text-sm text-muted-foreground">Withdrawn by the requester.</p>}
+
+      {outcome === "pending" && (
+        <div className="flex flex-col gap-3 border-t pt-4">
+          {canApprove ? (
+            <>
+              <Field>
+                <FieldLabel htmlFor="approval-comment">Comment (optional)</FieldLabel>
+                <Textarea id="approval-comment" rows={2} maxLength={250} value={comment} onChange={(e) => setComment(e.target.value)} />
+              </Field>
+              <p className="text-xs text-muted-foreground">
+                {isFinal ? `This is the final approval. ${props.finalEffect}` : "After you approve, a second, different person must approve it too."}
+              </p>
+              <div className="flex flex-col gap-2 sm:flex-row sm:justify-end">
+                <Button variant="outline" onClick={() => { setReasonError(null); setRejectOpen(true) }} disabled={busy !== null}>
+                  <X className="size-4" />
+                  Reject
+                </Button>
+                <Button onClick={() => run("approve", () => props.onApprove(comment.trim() || undefined))} disabled={busy !== null}>
+                  <Check className="size-4" />
+                  {busy === "approve" ? "Approving…" : isFinal ? "Approve & apply" : "Approve"}
+                </Button>
+              </div>
+            </>
+          ) : (
+            <p className="text-sm text-muted-foreground">{whyNot ?? "You can't approve this."}</p>
+          )}
+          {canWithdraw && (
+            <Button variant="ghost" size="sm" className="self-end" onClick={() => run("withdraw", props.onWithdraw)} disabled={busy !== null}>
+              <Undo2 className="size-4" />
+              {busy === "withdraw" ? "Withdrawing…" : "Withdraw my request"}
+            </Button>
+          )}
+        </div>
+      )}
+
+      <Dialog open={rejectOpen} onOpenChange={setRejectOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Reject this {what}</DialogTitle>
+            <DialogDescription>Nothing will be applied. The requester is told your reason.</DialogDescription>
+          </DialogHeader>
+          <Field data-invalid={!!reasonError}>
+            <FieldLabel htmlFor="reject-reason" required>Reason</FieldLabel>
+            <Textarea id="reject-reason" rows={3} maxLength={250} value={reason} onChange={(e) => { setReason(e.target.value); setReasonError(null) }} />
+            <FieldError errors={[reasonError ? { message: reasonError } : undefined]} />
+          </Field>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setRejectOpen(false)} disabled={busy === "reject"}>Keep it</Button>
+            <Button variant="destructive" onClick={reject} disabled={busy === "reject"}>{busy === "reject" ? "Rejecting…" : "Reject"}</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  )
+}
+
+function ordinal(level: number) {
+  return level === 1 ? "1st" : level === 2 ? "2nd" : `${level}th`
+}
+
+function Step({ state, title, detail }: { state: "done" | "rejected" | "waiting" | "idle"; title: string; detail: string }) {
+  const Icon = state === "done" ? Check : state === "rejected" ? X : CircleDashed
+  return (
+    <li className="flex items-start gap-3">
+      <span
+        className={cn(
+          "mt-0.5 flex size-6 shrink-0 items-center justify-center rounded-full",
+          state === "done" && "bg-success/15 text-success",
+          state === "rejected" && "bg-destructive/15 text-destructive",
+          state === "waiting" && "bg-warning/15 text-warning",
+          state === "idle" && "bg-muted text-muted-foreground"
+        )}
+      >
+        <Icon className="size-3.5" />
+      </span>
+      <div className="min-w-0">
+        <p className={cn("text-sm font-medium", state === "idle" ? "text-muted-foreground" : "text-foreground")}>{title}</p>
+        <p className="text-xs text-muted-foreground">{detail}</p>
+      </div>
+    </li>
+  )
+}
+
+const priceLabel: Record<PriceAdjustmentStatus, string> = {
+  PendingApproval: "Pending",
+  PendingSecondApproval: "Pending 2nd",
+  Approved: "Applied",
+  Rejected: "Rejected",
+  Cancelled: "Withdrawn",
+}
+
+export function PriceAdjustmentStatusBadge({ status }: { status: PriceAdjustmentStatus }) {
+  const tone =
+    status === "Approved" ? "bg-success/10 text-success"
+    : status === "Rejected" ? "bg-destructive/10 text-destructive"
+    : status === "Cancelled" ? "bg-muted text-muted-foreground"
+    : "bg-warning/10 text-warning"
+  return (
+    <Badge variant="outline" className={cn("h-6 w-28 justify-center border-transparent px-2.5 py-1 text-sm", tone)}>
+      {priceLabel[status]}
+    </Badge>
+  )
+}
diff --git a/Frontend/erp-system/components/approvals/ApprovalQueueButton.tsx b/Frontend/erp-system/components/approvals/ApprovalQueueButton.tsx
new file mode 100644
index 0000000..0b1b342
--- /dev/null
+++ b/Frontend/erp-system/components/approvals/ApprovalQueueButton.tsx
@@ -0,0 +1,36 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import Link from "next/link"
+import { ClipboardCheck } from "lucide-react"
+
+import { approvalsApi } from "@/lib/api/approvals"
+import { cn } from "@/lib/utils"
+import { ApprovalDocType } from "@/types/approvals"
+
+import { buttonVariants } from "@/components/ui/button"
+
+/**
+ * "Approval queue" button for list pages: opens the Approvals inbox and shows how many requests of
+ * this kind are waiting for the current user (docs/DUAL_APPROVAL_PLAN.md §10).
+ */
+export function ApprovalQueueButton({ docType, className }: { docType?: ApprovalDocType; className?: string }) {
+  const [count, setCount] = useState<number | null>(null)
+
+  useEffect(() => {
+    approvalsApi
+      .pending()
+      .then((p) => setCount(p.items.filter((i) => i.canApprove && (!docType || i.docType === docType)).length))
+      .catch(() => setCount(null))
+  }, [docType])
+
+  return (
+    <Link href="/dashboard/approvals" className={cn(buttonVariants({ variant: "outline", size: "lg" }), "w-full sm:w-auto", className)}>
+      <ClipboardCheck className="size-5" />
+      Approval queue
+      {count !== null && count > 0 && (
+        <span className="rounded-full bg-primary px-2 text-xs font-semibold leading-5 text-primary-foreground tabular-nums">{count}</span>
+      )}
+    </Link>
+  )
+}
diff --git a/Frontend/erp-system/components/customers/EditCustomerDialog.tsx b/Frontend/erp-system/components/customers/EditCustomerDialog.tsx
new file mode 100644
index 0000000..11a2965
--- /dev/null
+++ b/Frontend/erp-system/components/customers/EditCustomerDialog.tsx
@@ -0,0 +1,253 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+import { customersApi } from "@/lib/api/customers"
+import { errorMessage, fieldErrors } from "@/lib/error-map"
+import { Customer, CustomerType } from "@/types/customers"
+
+import { Button } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { toast } from "@/components/ui/toast"
+
+/**
+ * Edit popup for one customer, opened from the customers list and laid out like its
+ * "New customer" dialog. Mount it with `key={customerId}` so each open starts clean. The
+ * list rows carry no ETag, so the customer is re-read here for a fresh If-Match first.
+ */
+export function EditCustomerDialog({
+  customerId,
+  onClose,
+  onSaved,
+}: {
+  customerId: number
+  onClose: () => void
+  onSaved: (customer: Customer) => void
+}) {
+  const [customer, setCustomer] = useState<Customer | null>(null)
+  const [etag, setEtag] = useState<string | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+
+  const [customerCode, setCustomerCode] = useState("")
+  const [customerType, setCustomerType] = useState<CustomerType>("B2C")
+  const [name, setName] = useState("")
+  const [phone, setPhone] = useState("")
+  const [email, setEmail] = useState("")
+  const [addressLine1, setAddressLine1] = useState("")
+  const [addressLine2, setAddressLine2] = useState("")
+  const [city, setCity] = useState("")
+  const [country, setCountry] = useState("")
+  const [taxRegistrationNo, setTaxRegistrationNo] = useState("")
+  const [creditLimit, setCreditLimit] = useState("")
+  const [creditDays, setCreditDays] = useState("")
+  const [errors, setErrors] = useState<Record<string, string>>({})
+  const [saving, setSaving] = useState(false)
+
+  function applyCustomer(data: Customer, tag: string | null) {
+    setCustomer(data)
+    setEtag(tag)
+    setCustomerCode(data.customerCode)
+    setCustomerType(data.customerType)
+    setName(data.name)
+    setPhone(data.phone ?? "")
+    setEmail(data.email ?? "")
+    setAddressLine1(data.addressLine1 ?? "")
+    setAddressLine2(data.addressLine2 ?? "")
+    setCity(data.city ?? "")
+    setCountry(data.country ?? "")
+    setTaxRegistrationNo(data.taxRegistrationNo ?? "")
+    setCreditLimit(String(data.creditLimit))
+    setCreditDays(String(data.creditDays))
+  }
+
+  function reload() {
+    return customersApi.get(customerId).then(({ data, etag: tag }) => applyCustomer(data, tag))
+  }
+
+  useEffect(() => {
+    reload().catch((err) => setLoadError(errorMessage(err)))
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [customerId])
+
+  /** Drops a field's error once the user starts editing it. */
+  function clearError(key: string) {
+    setErrors((prev) => {
+      if (!prev[key]) return prev
+      const next = { ...prev }
+      delete next[key]
+      return next
+    })
+  }
+
+  async function handleSave() {
+    const nextErrors: Record<string, string> = {}
+    if (!customerCode.trim()) nextErrors.customerCode = "Customer code is required"
+    if (!name.trim()) nextErrors.name = "Customer name is required"
+    setErrors(nextErrors)
+    if (Object.keys(nextErrors).length > 0) {
+      toast.error("Could not save customer", Object.values(nextErrors)[0])
+      return
+    }
+    if (!customer || !etag) return
+
+    setSaving(true)
+    try {
+      const result = await customersApi.update(
+        customerId,
+        {
+          customerCode,
+          customerType,
+          name,
+          // Not editable in this popup — send the stored value back so the PUT doesn't clear it.
+          displayName: customer.displayName,
+          phone: phone || null,
+          email: email || null,
+          addressLine1: addressLine1 || null,
+          addressLine2: addressLine2 || null,
+          city: city || null,
+          country: country || null,
+          taxRegistrationNo: taxRegistrationNo || null,
+          creditLimit: Number(creditLimit) || 0,
+          creditDays: Number(creditDays) || 0,
+          defaultWarehouseId: customer.defaultWarehouseId,
+          branchId: customer.branchId,
+        },
+        etag
+      )
+      toast.success("Customer saved", `${result.data.customerCode} — ${result.data.name}`)
+      onSaved(result.data)
+    } catch (err) {
+      if ((err as { code?: string })?.code === "CONCURRENCY_CONFLICT") {
+        // Someone else saved first: show their version so the user can redo the edit on top of it.
+        toast.error("Customer was changed by someone else", "The latest details have been loaded — make your edit again.")
+        await reload().catch(() => {})
+        return
+      }
+      const fe = fieldErrors(err)
+      if (fe?.customerCode) setErrors({ customerCode: fe.customerCode })
+      toast.error("Could not save customer", errorMessage(err))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <Dialog open onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-lg">
+        <DialogHeader className="items-center text-center">
+          <DialogTitle>Edit customer</DialogTitle>
+          <DialogDescription>Update this customer&apos;s details.</DialogDescription>
+        </DialogHeader>
+
+        {loadError ? (
+          <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-4 text-base text-destructive">{loadError}</div>
+        ) : !customer ? (
+          <div className="flex flex-col gap-5">
+            {Array.from({ length: 6 }).map((_, i) => (
+              <Skeleton key={i} className="h-14 w-full" />
+            ))}
+          </div>
+        ) : (
+          <FieldGroup>
+            <Field data-invalid={!!errors.name}>
+              <FieldLabel htmlFor="ec-name" required>Name</FieldLabel>
+              <Input
+                id="ec-name"
+                value={name}
+                onChange={(e) => {
+                  setName(e.target.value)
+                  clearError("name")
+                }}
+                placeholder="Nimal Perera"
+                aria-invalid={!!errors.name}
+              />
+              <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
+            </Field>
+            <div className="grid grid-cols-2 gap-3">
+              <Field data-invalid={!!errors.customerCode}>
+                <FieldLabel htmlFor="ec-code" required>Code</FieldLabel>
+                <Input
+                  id="ec-code"
+                  value={customerCode}
+                  onChange={(e) => {
+                    setCustomerCode(e.target.value)
+                    clearError("customerCode")
+                  }}
+                  aria-invalid={!!errors.customerCode}
+                />
+                <FieldError errors={[errors.customerCode ? { message: errors.customerCode } : undefined]} />
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="ec-type">Customer type</FieldLabel>
+                <Select<CustomerType> value={customerType} onValueChange={(v) => v && setCustomerType(v)}>
+                  <SelectTrigger id="ec-type" className="w-full">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="B2C">B2C — individual</SelectItem>
+                    <SelectItem value="B2B">B2B — business</SelectItem>
+                  </SelectContent>
+                </Select>
+              </Field>
+            </div>
+            <div className="grid grid-cols-2 gap-3">
+              <Field>
+                <FieldLabel htmlFor="ec-phone">Phone (optional)</FieldLabel>
+                <Input id="ec-phone" value={phone} onChange={(e) => setPhone(e.target.value)} placeholder="0771234567" />
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="ec-email">Email (optional)</FieldLabel>
+                <Input id="ec-email" type="email" value={email} onChange={(e) => setEmail(e.target.value)} placeholder="customer@example.com" />
+              </Field>
+            </div>
+            <Field>
+              <FieldLabel htmlFor="ec-addr1">Address line 1 (optional)</FieldLabel>
+              <Input id="ec-addr1" value={addressLine1} onChange={(e) => setAddressLine1(e.target.value)} />
+            </Field>
+            <Field>
+              <FieldLabel htmlFor="ec-addr2">Address line 2 (optional)</FieldLabel>
+              <Input id="ec-addr2" value={addressLine2} onChange={(e) => setAddressLine2(e.target.value)} />
+            </Field>
+            <div className="grid grid-cols-2 gap-3">
+              <Field>
+                <FieldLabel htmlFor="ec-city">City (optional)</FieldLabel>
+                <Input id="ec-city" value={city} onChange={(e) => setCity(e.target.value)} />
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="ec-country">Country (optional)</FieldLabel>
+                <Input id="ec-country" value={country} onChange={(e) => setCountry(e.target.value)} />
+              </Field>
+            </div>
+            <Field>
+              <FieldLabel htmlFor="ec-tax">Tax registration (optional)</FieldLabel>
+              <Input id="ec-tax" value={taxRegistrationNo} onChange={(e) => setTaxRegistrationNo(e.target.value)} />
+            </Field>
+            <div className="grid grid-cols-2 gap-3">
+              <Field>
+                <FieldLabel htmlFor="ec-credit-limit">Credit limit (LKR)</FieldLabel>
+                <Input id="ec-credit-limit" type="number" min="0" step="0.01" placeholder="0" value={creditLimit} onChange={(e) => setCreditLimit(e.target.value)} />
+              </Field>
+              <Field>
+                <FieldLabel htmlFor="ec-credit-days">Credit days</FieldLabel>
+                <Input id="ec-credit-days" type="number" min="0" step="1" placeholder="0" value={creditDays} onChange={(e) => setCreditDays(e.target.value)} />
+              </Field>
+            </div>
+          </FieldGroup>
+        )}
+
+        <div className="flex flex-col-reverse gap-3 pt-2 sm:flex-row sm:justify-center">
+          <Button variant="outline" className="w-full sm:w-auto sm:min-w-36" onClick={onClose} disabled={saving}>
+            Cancel
+          </Button>
+          <Button className="w-full sm:w-auto sm:min-w-36" onClick={handleSave} disabled={saving || !customer}>
+            {saving ? "Saving…" : "Save"}
+          </Button>
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/Frontend/erp-system/components/invoice-template/InvoicePrintKit.tsx b/Frontend/erp-system/components/invoice-template/InvoicePrintKit.tsx
new file mode 100644
index 0000000..443a2b4
--- /dev/null
+++ b/Frontend/erp-system/components/invoice-template/InvoicePrintKit.tsx
@@ -0,0 +1,286 @@
+"use client"
+
+import { ReactNode, useRef, useState, useSyncExternalStore } from "react"
+import { createPortal } from "react-dom"
+import { Download, Loader2, Printer, Share2 } from "lucide-react"
+
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { Button } from "@/components/ui/button"
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
+import { Skeleton } from "@/components/ui/skeleton"
+import { toast } from "@/components/ui/toast"
+
+/*
+ * Shared plumbing for the printable invoice previews (sales and purchase): paper sizes, the
+ * sheet's building blocks, PDF export, and the preview frame with its Paper size / Share /
+ * Download / Print bar. Each invoice type only supplies its own A4 and receipt layouts.
+ */
+
+// Deep-red accent from the reference layout — used for the heading underlines and header rule.
+export const ACCENT = "#8b1c24"
+
+export type PaperSize = "A4" | "80mm" | "58mm"
+export type ReceiptWidth = Exclude<PaperSize, "A4">
+
+const PAPER_SIZES: { value: PaperSize; label: string; hint: string }[] = [
+  { value: "A4", label: "A4", hint: "210 × 297 mm" },
+  { value: "80mm", label: "80mm receipt", hint: "Thermal roll" },
+  { value: "58mm", label: "58mm receipt", hint: "Small thermal roll" },
+]
+
+/** Sets the printer's page box — the browser print dialog picks this up as the paper size. */
+const PAGE_RULES: Record<PaperSize, string> = {
+  A4: "@page { size: A4; margin: 12mm; }",
+  "80mm": "@page { size: 80mm auto; margin: 3mm; }",
+  "58mm": "@page { size: 58mm auto; margin: 2mm; }",
+}
+
+/** Receipt sheet sizing per roll — 58mm gets tighter padding and a smaller font to fit ~32 chars a line. */
+export const RECEIPT_SHEET_CLASS: Record<ReceiptWidth, string> = {
+  "80mm": "w-[80mm] px-[4mm] py-[5mm] text-[11px]",
+  "58mm": "w-[58mm] px-[2.5mm] py-[4mm] text-[9.5px]",
+}
+
+/** Screen chrome for the on-screen A4 page; in print the @page margin does the spacing. */
+export const A4_SHEET_CLASS =
+  "invoice-sheet mx-auto min-h-[297mm] w-[210mm] shrink-0 bg-white p-[12mm] text-sm text-neutral-800 shadow-md ring-1 ring-foreground/10 print:min-h-0 print:w-auto print:shadow-none print:ring-0"
+
+/** Screen chrome for a receipt roll; combine with RECEIPT_SHEET_CLASS[width]. */
+export const RECEIPT_SHEET_BASE_CLASS =
+  "invoice-sheet mx-auto shrink-0 bg-white leading-snug text-neutral-900 shadow-md ring-1 ring-foreground/10 print:w-auto print:p-0 print:shadow-none print:ring-0"
+
+export const printColorExact = { printColorAdjust: "exact", WebkitPrintColorAdjust: "exact" } as const
+
+export function money(n: number) {
+  return `Rs. ${n.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
+}
+
+export function qty(n: number) {
+  return n.toLocaleString(undefined, { maximumFractionDigits: 3 })
+}
+
+/** dd/MM/yyyy, as on the reference invoice. */
+export function formatDate(value: string | Date) {
+  const d = new Date(value)
+  return `${String(d.getDate()).padStart(2, "0")}/${String(d.getMonth() + 1).padStart(2, "0")}/${d.getFullYear()}`
+}
+
+/** Section heading with the short accent underline. */
+export function SectionTitle({ children }: { children: ReactNode }) {
+  return (
+    <div className="mb-3">
+      <h2 className="text-base font-bold text-neutral-900">{children}</h2>
+      <div className="mt-1 h-0.5 w-16" style={{ backgroundColor: ACCENT }} />
+    </div>
+  )
+}
+
+/** Dashed divider used between receipt sections. */
+export function ReceiptRule() {
+  return <div className="my-2 border-t border-dashed border-neutral-500" />
+}
+
+export function ReceiptRow({ label, value, bold }: { label: string; value: string; bold?: boolean }) {
+  return (
+    <div className={cn("flex justify-between gap-2", bold && "font-bold text-black")}>
+      <span>{label}</span>
+      <span className="tabular-nums">{value}</span>
+    </div>
+  )
+}
+
+/** Terms + footer note lines from the invoice template, blank lines dropped. */
+export function templateNotes(termsAndConditions?: string | null, footerNote?: string | null): string[] {
+  return [...(termsAndConditions ?? "").split("\n"), ...(footerNote ?? "").split("\n")].map((l) => l.trim()).filter(Boolean)
+}
+
+const subscribeNoop = () => () => {}
+
+/** True only on the client — the print copy is portalled into document.body. */
+function useIsClient() {
+  return useSyncExternalStore(subscribeNoop, () => true, () => false)
+}
+
+/** Paper width in mm — the PDF page is this wide; A4 is also 297mm tall (longer invoices add pages). */
+const PAPER_WIDTH_MM: Record<PaperSize, number> = { A4: 210, "80mm": 80, "58mm": 58 }
+const A4_HEIGHT_MM = 297
+
+/**
+ * Renders the on-screen sheet to a PDF that looks exactly like the preview: the sheet is captured
+ * as an image (html-to-image) and laid onto pages of the chosen paper size (jsPDF). A4 is split
+ * across as many 297mm pages as needed; a receipt is one page as long as the receipt itself.
+ * Both libraries are loaded on demand.
+ */
+async function buildInvoicePdf(sheet: HTMLElement, size: PaperSize): Promise<Blob> {
+  const [{ toPng }, { jsPDF }] = await Promise.all([import("html-to-image"), import("jspdf")])
+  // The sheet's drop shadow / ring are screen decoration only.
+  const dataUrl = await toPng(sheet, {
+    pixelRatio: 2,
+    backgroundColor: "#ffffff",
+    style: { boxShadow: "none", margin: "0" },
+    // A logo the browser can't read back (cross-origin, no CORS) becomes a blank instead of failing the whole PDF.
+    imagePlaceholder: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
+  })
+  const img = new Image()
+  img.src = dataUrl
+  await img.decode()
+
+  const widthMm = PAPER_WIDTH_MM[size]
+  const imgHeightMm = (img.height * widthMm) / img.width
+  if (size !== "A4") {
+    const pdf = new jsPDF({ unit: "mm", format: [widthMm, imgHeightMm] })
+    pdf.addImage(dataUrl, "PNG", 0, 0, widthMm, imgHeightMm)
+    return pdf.output("blob")
+  }
+  const pdf = new jsPDF({ unit: "mm", format: "a4" })
+  // Same image on every page, shifted up one page-height each time; the page box crops the rest.
+  for (let offset = 0, page = 0; offset < imgHeightMm - 0.5; offset += A4_HEIGHT_MM, page++) {
+    if (page > 0) pdf.addPage()
+    pdf.addImage(dataUrl, "PNG", 0, -offset, widthMm, imgHeightMm)
+  }
+  return pdf.output("blob")
+}
+
+function saveBlob(blob: Blob, filename: string) {
+  const url = URL.createObjectURL(blob)
+  const a = document.createElement("a")
+  a.href = url
+  a.download = filename
+  a.click()
+  setTimeout(() => URL.revokeObjectURL(url), 1000)
+}
+
+/**
+ * Invoice preview + paper-size bar underneath + Share / Download / Print. Printing uses a copy of
+ * the sheet portalled straight into <body> (`.invoice-print-root`, see globals.css) so the printout
+ * is just the invoice, whether this is rendered in a page or inside a dialog.
+ */
+export function InvoicePreviewFrame({
+  renderSheet,
+  error,
+  docNo,
+  shareTitle,
+  sharePath,
+  className,
+}: {
+  /** The invoice laid out for a paper size, or null while it is still loading. */
+  renderSheet: ((size: PaperSize) => ReactNode) | null
+  error: string | null
+  /** Used for the PDF file name. */
+  docNo: string
+  shareTitle: string
+  /** App path of a page showing this invoice — shared/copied where the PDF itself can't be. */
+  sharePath: string
+  className?: string
+}) {
+  const [paperSize, setPaperSize] = useState<PaperSize>("A4")
+  const isClient = useIsClient()
+  const previewRef = useRef<HTMLDivElement>(null)
+  const [busy, setBusy] = useState<"download" | "share" | null>(null)
+
+  const fileName = `${docNo}${paperSize === "A4" ? "" : `-${paperSize}`}.pdf`
+
+  async function makePdf(): Promise<Blob> {
+    const sheet = previewRef.current?.querySelector<HTMLElement>(".invoice-sheet")
+    if (!sheet) throw new Error("The invoice is still loading.")
+    return buildInvoicePdf(sheet, paperSize)
+  }
+
+  async function handleDownload() {
+    setBusy("download")
+    try {
+      saveBlob(await makePdf(), fileName)
+    } catch (err) {
+      toast.error("Could not create the PDF", errorMessage(err))
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  // Shares the PDF itself where the device supports sharing files (phones, most desktop Chrome/Edge);
+  // otherwise shares — or, failing that, copies — a link to this invoice's page.
+  async function handleShare() {
+    const link = `${window.location.origin}${sharePath}`
+    setBusy("share")
+    try {
+      const file = new File([await makePdf()], fileName, { type: "application/pdf" })
+      if (navigator.canShare?.({ files: [file] })) {
+        await navigator.share({ files: [file], title: shareTitle, text: shareTitle })
+      } else if (navigator.share) {
+        await navigator.share({ title: shareTitle, text: shareTitle, url: link })
+      } else {
+        await navigator.clipboard.writeText(link)
+        toast.success("Link copied", "Sharing files isn't supported here — the invoice link is on your clipboard.")
+      }
+    } catch (err) {
+      // Closing the share sheet isn't an error.
+      if (!(err instanceof DOMException && err.name === "AbortError")) toast.error("Could not share the invoice", errorMessage(err))
+    } finally {
+      setBusy(null)
+    }
+  }
+
+  if (error && !renderSheet) {
+    return <div className="m-4 rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
+  }
+
+  return (
+    <div className={cn("flex min-h-0 flex-col", className)}>
+      {/* Preview window — scrolls so the page keeps its true size. */}
+      <div ref={previewRef} className="min-h-0 flex-1 overflow-auto bg-muted/40 p-4 sm:p-6">
+        {renderSheet ? renderSheet(paperSize) : <Skeleton className="mx-auto h-[297mm] w-[210mm] max-w-full" />}
+      </div>
+
+      {/* Paper size selection, under the invoice. */}
+      <div className="flex flex-col gap-3 border-t bg-card p-4 sm:flex-row sm:items-center sm:justify-between">
+        <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:gap-3">
+          <label htmlFor="invoice-paper-size" className="text-sm font-semibold text-foreground">Paper size</label>
+          <Select<PaperSize>
+            value={paperSize}
+            onValueChange={(v) => v && setPaperSize(v)}
+            items={PAPER_SIZES.map((s) => ({ value: s.value, label: s.label }))}
+          >
+            <SelectTrigger id="invoice-paper-size" className="h-10! w-56 text-sm">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              {PAPER_SIZES.map((s) => (
+                <SelectItem key={s.value} value={s.value}>
+                  <span className="flex flex-col">
+                    <span className="text-sm font-medium">{s.label}</span>
+                    <span className="text-xs text-muted-foreground">{s.hint}</span>
+                  </span>
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+        <div className="flex flex-wrap gap-2">
+          <Button size="lg" variant="outline" onClick={handleShare} disabled={!renderSheet || busy !== null}>
+            {busy === "share" ? <Loader2 className="size-4 animate-spin" /> : <Share2 className="size-4" />}
+            Share
+          </Button>
+          <Button size="lg" variant="outline" onClick={handleDownload} disabled={!renderSheet || busy !== null}>
+            {busy === "download" ? <Loader2 className="size-4 animate-spin" /> : <Download className="size-4" />}
+            Download
+          </Button>
+          <Button size="lg" onClick={() => window.print()} disabled={!renderSheet}>
+            <Printer className="size-4" />
+            Print {paperSize === "A4" ? "A4" : `${paperSize} receipt`}
+          </Button>
+        </div>
+      </div>
+
+      {isClient &&
+        renderSheet &&
+        createPortal(
+          <div className="invoice-print-root">
+            <style>{PAGE_RULES[paperSize]}</style>
+            {renderSheet(paperSize)}
+          </div>,
+          document.body
+        )}
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/components/procurement/PurchaseInvoicePaymentDialog.tsx b/Frontend/erp-system/components/procurement/PurchaseInvoicePaymentDialog.tsx
index fcef274..f623de8 100644
--- a/Frontend/erp-system/components/procurement/PurchaseInvoicePaymentDialog.tsx
+++ b/Frontend/erp-system/components/procurement/PurchaseInvoicePaymentDialog.tsx
@@ -13,8 +13,8 @@ import { Button } from "@/components/ui/button"
 import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
 import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
 import { Input } from "@/components/ui/input"
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
 import { toast } from "@/components/ui/toast"
+import { localToday, PaymentLine, PaymentLinesEditor, round2, validatePaymentLines } from "@/components/sales/PaymentLinesEditor"
 
 interface PurchaseInvoicePaymentDialogProps {
   // PurchaseInvoiceSummary rather than the full PurchaseInvoice — every field this dialog
@@ -24,23 +24,34 @@ interface PurchaseInvoicePaymentDialogProps {
   invoice: PurchaseInvoiceSummary | null
   open: boolean
   onOpenChange: (open: boolean) => void
-  /** `newStatus` is always "Posted" — paying only ever succeeds against a posted invoice, whether
-   * it started that way or this dialog auto-posted it first. */
+  /** Called once per recorded payment line. `newStatus` is always "Posted" — paying only ever
+   * succeeds against a posted invoice, whether it started that way or this dialog auto-posted it. */
   onPaid: (payment: PurchaseInvoicePayment, newStatus: PurchaseInvoiceStatus) => void
+  /** Called once, after the dialog closes, when this submit cleared the whole balance. */
+  onFullyPaid?: () => void
 }
 
-/** Record a vendor payment against a Purchase Invoice's balance — full or partial, into an
- * existing GL cash/bank account. A Draft invoice is posted first (the backend only accepts
- * payments against a Posted invoice) so this doubles as "confirm and pay in one step" from a
- * list row; an already-Posted invoice skips straight to payment. Modeled on
- * SalesInvoicePaymentDialog's "pick an account, submit" shape. */
-export function PurchaseInvoicePaymentDialog({ invoice, open, onOpenChange, onPaid }: PurchaseInvoicePaymentDialogProps) {
+/** Record a vendor payment against a Purchase Invoice's balance — full or partial, split across
+ * one or more payment lines (e.g. part cash, part bank), each from an existing GL cash/bank
+ * account. Same shape as SalesInvoicePaymentDialog: each line is posted as its own payment (the
+ * backend already allows several installments). A Draft invoice is posted first (the backend only
+ * accepts payments against a Posted invoice) so this doubles as "confirm and pay in one step" from
+ * a list row. If a line fails part-way, the lines already recorded are removed from the form and
+ * the rest stay for a retry. */
+export function PurchaseInvoicePaymentDialog({ invoice, open, onOpenChange, onPaid, onFullyPaid }: PurchaseInvoicePaymentDialogProps) {
   const [accounts, setAccounts] = useState<CashAndBankAccountDto[] | null>(null)
-  const [glBankAccountId, setGlBankAccountId] = useState("")
-  const [amount, setAmount] = useState("")
+  const [lines, setLines] = useState<PaymentLine[]>([])
   const [reference, setReference] = useState("")
+  const [paymentDate, setPaymentDate] = useState(localToday)
   const [errors, setErrors] = useState<Record<string, string>>({})
   const [submitting, setSubmitting] = useState(false)
+  // What this dialog has already done to the invoice in this session — the `invoice` prop isn't
+  // guaranteed to be refreshed by the parent between a partial failure and the retry.
+  const [postedHere, setPostedHere] = useState(false)
+  const [paidHere, setPaidHere] = useState(0)
+  // Balance as it stood when the dialog opened. The parent pages apply each `onPaid` to the
+  // invoice they pass in, so subtracting `paidHere` from the live prop would count it twice.
+  const [openingBalance, setOpeningBalance] = useState(0)
 
   // Reset the form fields for a fresh open (or a different invoice) during render — same
   // "adjust state while rendering" pattern as SalesInvoicePaymentDialog, not inside an effect.
@@ -48,10 +59,13 @@ export function PurchaseInvoicePaymentDialog({ invoice, open, onOpenChange, onPa
   const [resetFor, setResetFor] = useState<string | null>(null)
   if (openKey !== null && resetFor !== openKey) {
     setResetFor(openKey)
-    setAmount(invoice!.totals.balanceAmount.toFixed(2))
-    setGlBankAccountId("")
+    setLines([{ key: 0, glBankAccountId: "", amount: invoice!.totals.balanceAmount.toFixed(2) }])
     setReference("")
+    setPaymentDate(localToday())
     setErrors({})
+    setPostedHere(false)
+    setPaidHere(0)
+    setOpeningBalance(invoice!.totals.balanceAmount)
   }
 
   useEffect(() => {
@@ -61,98 +75,120 @@ export function PurchaseInvoicePaymentDialog({ invoice, open, onOpenChange, onPa
 
   if (!invoice) return null
 
+  const isDraft = invoice.status === "Draft" && !postedHere
+  const balance = round2(openingBalance - paidHere)
+
   async function submit() {
     if (!invoice) return
-    const nextErrors: Record<string, string> = {}
-    const amountNum = Number(amount)
-    if (!glBankAccountId) nextErrors.glBankAccountId = "Select an account to pay from"
-    if (!amount || Number.isNaN(amountNum) || amountNum <= 0) nextErrors.amount = "Enter a valid amount"
-    else if (amountNum > invoice.totals.balanceAmount) nextErrors.amount = `Cannot exceed the balance (${formatAmount(invoice.totals.balanceAmount)})`
+    const nextErrors = validatePaymentLines(lines, balance)
+    if (!paymentDate) nextErrors.paymentDate = "Select the payment date"
+    else if (paymentDate > localToday()) nextErrors.paymentDate = "Payment date cannot be in the future"
     setErrors(nextErrors)
     if (Object.keys(nextErrors).length > 0) return
 
     setSubmitting(true)
-    try {
-      if (invoice.status === "Draft") {
-        try {
-          await purchaseInvoicesApi.post(invoice.purchaseInvoiceId)
-        } catch (err) {
-          toast.error("Could not confirm invoice", errorMessage(err))
-          return
-        }
+    if (isDraft) {
+      try {
+        await purchaseInvoicesApi.post(invoice.purchaseInvoiceId)
+        setPostedHere(true)
+      } catch (err) {
+        toast.error("Could not confirm invoice", errorMessage(err))
+        setSubmitting(false)
+        return
       }
+    }
 
-      const payment = await purchaseInvoicesApi.pay(invoice.purchaseInvoiceId, {
-        amount: amountNum,
-        glBankAccountId: Number(glBankAccountId),
-        reference: reference || undefined,
-      })
-      const fullyPaid = amountNum >= invoice.totals.balanceAmount
+    // One payment per line, in order. On a failure, stop: drop the recorded lines from the form and
+    // keep the rest so the user can fix and retry without double-paying.
+    const recorded: PurchaseInvoicePayment[] = []
+    let failure: unknown = null
+    for (const line of lines) {
+      try {
+        const payment = await purchaseInvoicesApi.pay(invoice.purchaseInvoiceId, {
+          amount: Number(line.amount),
+          glBankAccountId: Number(line.glBankAccountId),
+          reference: reference || undefined,
+          paymentDate,
+        })
+        recorded.push(payment)
+        onPaid(payment, "Posted")
+      } catch (err) {
+        failure = err
+        break
+      }
+    }
+    setSubmitting(false)
+
+    const recordedTotal = round2(recorded.reduce((sum, p) => sum + p.amount, 0))
+    if (failure === null) {
+      const journals = recorded.map((p) => p.glJournalNo ?? "—").join(", ")
+      const fullyPaid = recordedTotal >= balance
       toast.success(
         invoice.status === "Draft" ? "Invoice confirmed and paid" : "Payment recorded",
-        `${formatAmount(amountNum)} posted to the ledger (${payment.glJournalNo ?? "—"}) — ${fullyPaid ? "fully paid" : "partially paid"}.`
+        `${formatAmount(recordedTotal)} posted to the ledger (${journals}) — ${fullyPaid ? "fully paid" : "partially paid"}.`
       )
-      onPaid(payment, "Posted")
       onOpenChange(false)
-    } catch (err) {
-      toast.error(
-        invoice.status === "Draft" ? "Invoice was confirmed, but the payment could not be recorded" : "Could not record payment",
-        errorMessage(err)
-      )
-    } finally {
-      setSubmitting(false)
+      if (fullyPaid) onFullyPaid?.()
+      return
     }
+
+    setPaidHere((p) => round2(p + recordedTotal))
+    setLines((prev) => prev.slice(recorded.length))
+    toast.error(
+      recorded.length > 0
+        ? `${recorded.length} of ${lines.length} payment lines recorded (${formatAmount(recordedTotal)}); the rest could not be`
+        : invoice.status === "Draft"
+          ? "Invoice was confirmed, but the payment could not be recorded"
+          : "Could not record payment",
+      errorMessage(failure)
+    )
   }
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="sm:max-w-md">
+      <DialogContent className="sm:max-w-xl">
         <DialogHeader>
-          <DialogTitle>{invoice.status === "Draft" ? "Confirm & pay" : "Pay"} invoice {invoice.docNo}</DialogTitle>
+          <DialogTitle>{isDraft ? "Confirm & pay" : "Pay"} invoice {invoice.docNo}</DialogTitle>
         </DialogHeader>
 
         <p className="text-sm text-muted-foreground">
-          {invoice.status === "Draft" && "This invoice is still a draft — submitting will confirm it, then record the payment. "}
-          Balance due: <span className="font-medium text-foreground tabular-nums">{formatAmount(invoice.totals.balanceAmount)}</span>
+          {isDraft && "This invoice is still a draft — submitting will confirm it, then record the payment. "}
+          Balance due: <span className="font-medium text-foreground tabular-nums">{formatAmount(balance)}</span>
         </p>
 
         <FieldGroup>
-          <Field data-invalid={!!errors.glBankAccountId}>
-            <FieldLabel htmlFor="pinv-pay-account">Pay from</FieldLabel>
-            <Select<string> value={glBankAccountId} onValueChange={(v) => setGlBankAccountId(v ?? "")}>
-              <SelectTrigger id="pinv-pay-account" className="w-full text-base" aria-invalid={!!errors.glBankAccountId}>
-                <SelectValue placeholder={accounts === null ? "Loading…" : "Select a cash/bank account"} />
-              </SelectTrigger>
-              <SelectContent>
-                {(accounts ?? []).map((a) => (
-                  <SelectItem key={a.accountId} value={String(a.accountId)} label={a.accountName} className="text-base">
-                    {a.accountName} ({a.accountType})
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
-            <FieldError errors={[errors.glBankAccountId ? { message: errors.glBankAccountId } : undefined]} />
-          </Field>
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+            <Field>
+              <FieldLabel htmlFor="pinv-pay-invoice-no">Invoice no.</FieldLabel>
+              <Input
+                id="pinv-pay-invoice-no"
+                value={invoice.docNo}
+                readOnly
+                tabIndex={-1}
+                className="cursor-not-allowed bg-muted text-muted-foreground"
+              />
+            </Field>
 
-          <Field data-invalid={!!errors.amount}>
-            <FieldLabel htmlFor="pinv-pay-amount">Amount</FieldLabel>
-            <Input
-              id="pinv-pay-amount"
-              type="number"
-              step="0.01"
-              min="0.01"
-              max={invoice.totals.balanceAmount}
-              value={amount}
-              onChange={(e) => setAmount(e.target.value)}
-              aria-invalid={!!errors.amount}
-            />
-            <FieldError errors={[errors.amount ? { message: errors.amount } : undefined]} />
-          </Field>
+            <Field data-invalid={!!errors.paymentDate}>
+              <FieldLabel htmlFor="pinv-pay-date" required>Payment date</FieldLabel>
+              <Input
+                id="pinv-pay-date"
+                type="date"
+                max={localToday()}
+                value={paymentDate}
+                onChange={(e) => setPaymentDate(e.target.value)}
+                aria-invalid={!!errors.paymentDate}
+              />
+              <FieldError errors={[errors.paymentDate ? { message: errors.paymentDate } : undefined]} />
+            </Field>
+          </div>
 
           <Field>
             <FieldLabel htmlFor="pinv-pay-reference">Reference (optional)</FieldLabel>
             <Input id="pinv-pay-reference" value={reference} onChange={(e) => setReference(e.target.value)} />
           </Field>
+
+          <PaymentLinesEditor lines={lines} onChange={setLines} accounts={accounts} balance={balance} errors={errors} />
         </FieldGroup>
 
         <DialogFooter>
@@ -160,11 +196,7 @@ export function PurchaseInvoicePaymentDialog({ invoice, open, onOpenChange, onPa
             Cancel
           </Button>
           <Button onClick={submit} disabled={submitting}>
-            {submitting
-              ? "Recording…"
-              : invoice.status === "Draft"
-                ? "Confirm & record payment"
-                : "Record payment"}
+            {submitting ? "Recording…" : isDraft ? "Confirm & record payment" : "Record payment"}
           </Button>
         </DialogFooter>
       </DialogContent>
diff --git a/Frontend/erp-system/components/procurement/PurchaseInvoicePrint.tsx b/Frontend/erp-system/components/procurement/PurchaseInvoicePrint.tsx
new file mode 100644
index 0000000..1bfb559
--- /dev/null
+++ b/Frontend/erp-system/components/procurement/PurchaseInvoicePrint.tsx
@@ -0,0 +1,386 @@
+"use client"
+
+import { ReactNode, useEffect, useState } from "react"
+
+import { purchaseInvoicesApi } from "@/lib/api/purchase-invoices"
+import { vendorsApi } from "@/lib/api/vendors"
+import { companyProfileApi } from "@/lib/api/company-profile"
+import { invoiceTemplateConfigApi } from "@/lib/api/invoice-template-config"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { Dialog, DialogContent, DialogDescription, DialogTitle } from "@/components/ui/dialog"
+import {
+  A4_SHEET_CLASS,
+  ACCENT,
+  formatDate,
+  InvoicePreviewFrame,
+  money,
+  PaperSize,
+  printColorExact,
+  RECEIPT_SHEET_BASE_CLASS,
+  RECEIPT_SHEET_CLASS,
+  ReceiptRow,
+  ReceiptRule,
+  ReceiptWidth,
+  SectionTitle,
+  templateNotes,
+} from "@/components/invoice-template/InvoicePrintKit"
+import { CompanyProfile } from "@/types/company-profile"
+import { InvoiceTemplateConfig } from "@/types/invoice-template"
+import { Vendor } from "@/types/master-data"
+import { PurchaseInvoice, PurchaseInvoicePayment } from "@/types/purchase-invoices"
+
+/*
+ * Printable purchase invoice (vendor bill) in the same three paper sizes as the sales invoice —
+ * A4, 80mm and 58mm receipt — sharing its preview frame, PDF export and print plumbing. The
+ * lines are the GRNs the bill covers; "From" is the vendor and "Bill To" is our company.
+ */
+
+/** Everything both layouts render, resolved once. */
+interface PurchaseInvoiceDoc {
+  invoice: PurchaseInvoice
+  vendor: Vendor | null
+  payments: PurchaseInvoicePayment[]
+  company: CompanyProfile | null
+  template: InvoiceTemplateConfig | null
+  notes: string[]
+  showLogo: boolean
+}
+
+function A4Sheet({ invoice, vendor, payments, company, template, notes, showLogo }: PurchaseInvoiceDoc) {
+  const t = invoice.totals
+  return (
+    <div className={A4_SHEET_CLASS} style={printColorExact}>
+      {/* Title + meta */}
+      <div className="flex items-start justify-between gap-6">
+        <div>
+          <h1 className="text-4xl font-extrabold tracking-wide text-neutral-900">PURCHASE INVOICE</h1>
+          <dl className="mt-5 grid grid-cols-[auto_1fr] gap-x-10 gap-y-1.5">
+            <dt className="text-xs font-bold text-neutral-900">Invoice No.</dt>
+            <dd>{invoice.docNo}</dd>
+            <dt className="text-xs font-bold text-neutral-900">Vendor Invoice No.</dt>
+            <dd>{invoice.vendorInvoiceNo}</dd>
+            <dt className="text-xs font-bold text-neutral-900">Invoice Date</dt>
+            <dd>{formatDate(invoice.vendorInvoiceDate)}</dd>
+            {invoice.status !== "Posted" && (
+              <>
+                <dt className="text-xs font-bold text-neutral-900">Status</dt>
+                <dd className="font-semibold" style={{ color: ACCENT }}>{invoice.status.toUpperCase()}</dd>
+              </>
+            )}
+          </dl>
+        </div>
+        {showLogo && (
+          // eslint-disable-next-line @next/next/no-img-element -- print view, no next/image optimization needed
+          <img src={company!.logoUrl!} alt={company!.legalName} className="h-16 w-auto max-w-45 object-contain" />
+        )}
+      </div>
+
+      {/* Header rule: heavy dark bar over a thin accent line */}
+      <div className="mt-5 mb-7">
+        <div className="h-1 bg-neutral-900" />
+        <div className="mt-0.5 h-0.5" style={{ backgroundColor: ACCENT }} />
+      </div>
+
+      {/* From (vendor) / Bill To (us) */}
+      <div className="grid grid-cols-2 gap-10">
+        <div>
+          <SectionTitle>From</SectionTitle>
+          <div className="leading-snug">
+            <p className="font-bold text-neutral-900">{invoice.vendorSnapshotName}</p>
+            {vendor?.code && <p>Vendor code: {vendor.code}</p>}
+            <div className="mt-2">
+              {invoice.vendorSnapshotTaxNo && <p>Tax No: {invoice.vendorSnapshotTaxNo}</p>}
+              {vendor?.terms && <p>Terms: {vendor.terms}</p>}
+            </div>
+          </div>
+        </div>
+
+        <div>
+          <SectionTitle>Bill To</SectionTitle>
+          {company ? (
+            <div className="leading-snug">
+              <p className="font-bold text-neutral-900">{company.tradeName || company.legalName}</p>
+              <p>{[company.addressLine1, company.addressLine2].filter(Boolean).join(", ")}</p>
+              <p>{[company.city, company.country].filter(Boolean).join(", ")}</p>
+              <div className="mt-2">
+                {company.phone && <p>{company.phone}</p>}
+                {company.email && <p>{company.email}</p>}
+                {template?.showTaxRegNo && company.taxRegistrationNo && <p>Tax Reg No: {company.taxRegistrationNo}</p>}
+              </div>
+            </div>
+          ) : (
+            <p className="text-neutral-500 print:hidden">Company details aren&apos;t set up yet (Settings → Company Profile).</p>
+          )}
+        </div>
+      </div>
+
+      {/* GRN lines */}
+      <div className="mt-8">
+        <SectionTitle>Goods Received</SectionTitle>
+        <table className="w-full border-collapse">
+          <thead>
+            <tr className="border-y-2 border-neutral-900 text-xs font-bold text-neutral-900">
+              <th className="px-2 py-2.5 text-left">GRN</th>
+              <th className="px-2 py-2.5 text-left">Received</th>
+              <th className="px-2 py-2.5 text-right">Subtotal</th>
+              <th className="px-2 py-2.5 text-right">VAT</th>
+              <th className="px-2 py-2.5 text-right">Amount</th>
+            </tr>
+          </thead>
+          <tbody>
+            {invoice.lines.map((line) => (
+              <tr key={line.purchaseInvoiceLineId} className="border-b border-neutral-300">
+                <td className="px-2 py-2.5">{line.grnDocNo}</td>
+                <td className="px-2 py-2.5">{formatDate(line.grnPostedAt)}</td>
+                <td className="px-2 py-2.5 text-right tabular-nums">{money(line.subtotal)}</td>
+                <td className="px-2 py-2.5 text-right tabular-nums">{line.vatTotal > 0 ? money(line.vatTotal) : "—"}</td>
+                <td className="px-2 py-2.5 text-right font-medium tabular-nums">{money(line.lineTotal)}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      {/* Notes / totals */}
+      <div className="mt-6 grid grid-cols-[1fr_290px] items-start gap-8 print:break-inside-avoid">
+        <div>
+          {notes.length > 0 && (
+            <>
+              <SectionTitle>Notes / Terms</SectionTitle>
+              <ul className="text-xs">
+                {notes.map((note, i) => (
+                  <li key={i} className="border-b border-neutral-300 py-1.5">{note}</li>
+                ))}
+              </ul>
+            </>
+          )}
+        </div>
+
+        <div className="border border-neutral-900">
+          <div className="space-y-1.5 px-3.5 py-3 text-xs">
+            <div className="flex justify-between font-bold text-neutral-900"><span>Subtotal</span><span className="tabular-nums">{money(t.subtotal)}</span></div>
+            {t.vatTotal > 0 && <div className="flex justify-between"><span>VAT</span><span className="tabular-nums">{money(t.vatTotal)}</span></div>}
+          </div>
+          <div className="flex justify-between border-t border-neutral-300 bg-neutral-100 px-3.5 py-3 text-sm font-bold text-neutral-900">
+            <span>Total</span>
+            <span className="tabular-nums">{money(t.grandTotal)}</span>
+          </div>
+          {t.paidAmount > 0 && (
+            <div className="space-y-1.5 border-t border-neutral-300 px-3.5 py-3 text-xs">
+              <div className="flex justify-between"><span>Paid</span><span className="tabular-nums">{money(t.paidAmount)}</span></div>
+              <div className="flex justify-between font-bold text-neutral-900"><span>Balance Due</span><span className="tabular-nums">{money(t.balanceAmount)}</span></div>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Payments */}
+      <div className="mt-8 print:break-inside-avoid">
+        <SectionTitle>Payments</SectionTitle>
+        {payments.length > 0 ? (
+          <ul className="text-xs">
+            {payments.map((p) => (
+              <li key={p.purchaseInvoicePaymentId} className="flex justify-between gap-4 border-b border-neutral-300 py-1.5">
+                <span>
+                  {formatDate(p.paymentDate)} · {p.bankAccountName}
+                  {p.reference && <span className="text-neutral-500"> · Ref {p.reference}</span>}
+                </span>
+                <span className="font-medium tabular-nums">{money(p.amount)}</span>
+              </li>
+            ))}
+          </ul>
+        ) : (
+          <p className="text-xs text-neutral-500">No payment recorded yet.</p>
+        )}
+      </div>
+    </div>
+  )
+}
+
+/** 80mm / 58mm thermal layout: one centred column, no fills (thermal heads print black only). */
+function ReceiptSheet({ invoice, payments, company, template, notes, showLogo, width }: PurchaseInvoiceDoc & { width: ReceiptWidth }) {
+  const t = invoice.totals
+  return (
+    <div className={cn(RECEIPT_SHEET_BASE_CLASS, RECEIPT_SHEET_CLASS[width])} style={printColorExact}>
+      <div className="text-center">
+        {showLogo && (
+          // eslint-disable-next-line @next/next/no-img-element -- print view, no next/image optimization needed
+          <img src={company!.logoUrl!} alt={company!.legalName} className="mx-auto mb-1.5 h-10 w-auto max-w-[50mm] object-contain grayscale" />
+        )}
+        {company && (
+          <>
+            <p className="text-sm font-bold uppercase">{company.tradeName || company.legalName}</p>
+            <p>{[company.addressLine1, company.addressLine2, company.city].filter(Boolean).join(", ")}</p>
+            {company.phone && <p>Tel: {company.phone}</p>}
+            {template?.showTaxRegNo && company.taxRegistrationNo && <p>Tax Reg: {company.taxRegistrationNo}</p>}
+          </>
+        )}
+        <p className="mt-2 text-sm font-extrabold tracking-[0.15em]">PURCHASE INVOICE</p>
+        {invoice.status !== "Posted" && <p className="font-bold">*** {invoice.status.toUpperCase()} ***</p>}
+      </div>
+
+      <ReceiptRule />
+      <ReceiptRow label="Invoice No." value={invoice.docNo} />
+      <ReceiptRow label="Vendor Inv." value={invoice.vendorInvoiceNo} />
+      <ReceiptRow label="Date" value={formatDate(invoice.vendorInvoiceDate)} />
+      <ReceiptRow label="Vendor" value={invoice.vendorSnapshotName} />
+
+      <ReceiptRule />
+      <div className="flex justify-between font-bold">
+        <span>GRN</span>
+        <span>Amount</span>
+      </div>
+      <ReceiptRule />
+      <div className="space-y-1.5">
+        {invoice.lines.map((line) => (
+          <div key={line.purchaseInvoiceLineId}>
+            <p className="font-medium">{line.grnDocNo}</p>
+            <div className="flex justify-between gap-2 tabular-nums">
+              <span>{formatDate(line.grnPostedAt)}</span>
+              <span>{money(line.lineTotal)}</span>
+            </div>
+            {line.vatTotal > 0 && <p className="text-right tabular-nums">incl. VAT {money(line.vatTotal)}</p>}
+          </div>
+        ))}
+      </div>
+
+      <ReceiptRule />
+      <ReceiptRow label="Subtotal" value={money(t.subtotal)} />
+      {t.vatTotal > 0 && <ReceiptRow label="VAT" value={money(t.vatTotal)} />}
+      <div className="my-1.5 border-y-2 border-black py-1 text-sm">
+        <ReceiptRow label="TOTAL" value={money(t.grandTotal)} bold />
+      </div>
+      {t.paidAmount > 0 && (
+        <>
+          <ReceiptRow label="Paid" value={money(t.paidAmount)} />
+          <ReceiptRow label="Balance" value={money(t.balanceAmount)} bold />
+        </>
+      )}
+
+      {payments.length > 0 && (
+        <>
+          <ReceiptRule />
+          <p className="font-bold">Payment</p>
+          {payments.map((p) => (
+            <ReceiptRow key={p.purchaseInvoicePaymentId} label={`${formatDate(p.paymentDate)} ${p.bankAccountName}`} value={money(p.amount)} />
+          ))}
+        </>
+      )}
+
+      {notes.length > 0 && (
+        <>
+          <ReceiptRule />
+          {notes.map((note, i) => <p key={i} className="text-center">{note}</p>)}
+        </>
+      )}
+    </div>
+  )
+}
+
+/** Loads the invoice plus the optional decoration around it (vendor, payments, company, template).
+ * Only the invoice is required — any other failure just leaves that block out. */
+function usePurchaseInvoiceDoc(purchaseInvoiceId: number, refreshKey = 0) {
+  const [doc, setDoc] = useState<PurchaseInvoiceDoc | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const error = Number.isFinite(purchaseInvoiceId) ? loadError : `Invalid purchase invoice id '${purchaseInvoiceId}'.`
+
+  useEffect(() => {
+    if (!Number.isFinite(purchaseInvoiceId)) return
+    let cancelled = false
+    purchaseInvoicesApi
+      .get(purchaseInvoiceId)
+      .then(async ({ data: invoice }) => {
+        const [vendorRes, payments, companyRes, templateRes] = await Promise.all([
+          vendorsApi.get(invoice.vendorId).catch(() => null),
+          invoice.status === "Posted" ? purchaseInvoicesApi.listPayments(purchaseInvoiceId).catch(() => []) : Promise.resolve([]),
+          companyProfileApi.get().catch(() => ({ data: null, etag: null })),
+          invoiceTemplateConfigApi.get().catch(() => ({ data: null, etag: null })),
+        ])
+        if (cancelled) return
+        const company = companyRes.data
+        const template = templateRes.data
+        setDoc({
+          invoice,
+          vendor: vendorRes?.data ?? null,
+          payments,
+          company,
+          template,
+          notes: templateNotes(template?.termsAndConditions, template?.footerNote),
+          showLogo: template?.logoPlacement !== "None" && !!company?.logoUrl,
+        })
+      })
+      .catch((err) => {
+        if (!cancelled) setLoadError(errorMessage(err))
+      })
+    return () => {
+      cancelled = true
+    }
+    // refreshKey: bumped by the caller after a payment so the sheet shows the new state.
+  }, [purchaseInvoiceId, refreshKey])
+
+  return { doc, error }
+}
+
+function Sheet({ size, doc }: { size: PaperSize; doc: PurchaseInvoiceDoc }) {
+  return size === "A4" ? <A4Sheet {...doc} /> : <ReceiptSheet {...doc} width={size} />
+}
+
+/** Purchase invoice preview + paper-size bar underneath + Share / Download / Print. */
+export function PurchaseInvoicePrintPreview({
+  purchaseInvoiceId,
+  className,
+  refreshKey,
+}: {
+  purchaseInvoiceId: number
+  className?: string
+  refreshKey?: number
+}) {
+  const { doc, error } = usePurchaseInvoiceDoc(purchaseInvoiceId, refreshKey)
+  return (
+    <InvoicePreviewFrame
+      renderSheet={doc ? (size) => <Sheet size={size} doc={doc} /> : null}
+      error={error}
+      docNo={doc?.invoice.docNo ?? `purchase-invoice-${purchaseInvoiceId}`}
+      shareTitle={`Purchase invoice ${doc?.invoice.docNo ?? ""}`.trim()}
+      sharePath={`/dashboard/procurement/purchase-invoices/${purchaseInvoiceId}`}
+      className={className}
+    />
+  )
+}
+
+/** Popup form of the print preview — same frame as SalesInvoicePrintDialog. Opens on A4 every time. */
+export function PurchaseInvoicePrintDialog({
+  purchaseInvoiceId,
+  invoiceNo,
+  open,
+  onOpenChange,
+  actions,
+  refreshKey,
+}: {
+  purchaseInvoiceId: number | null
+  invoiceNo?: string
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  /** Optional buttons shown in the header (e.g. Record payment). */
+  actions?: ReactNode
+  /** Bump to reload the invoice (after a payment, …). */
+  refreshKey?: number
+}) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="flex h-[92vh] max-w-[calc(100%-2rem)] flex-col gap-0 overflow-hidden p-0 sm:max-w-[min(960px,calc(100%-2rem))]">
+        <div className="flex flex-col gap-3 border-b px-5 py-4 pr-12 sm:flex-row sm:items-center sm:justify-between">
+          <div>
+            <DialogTitle className="text-lg font-semibold">Purchase invoice{invoiceNo ? ` ${invoiceNo}` : ""}</DialogTitle>
+            <DialogDescription>Preview, pick a paper size below, then print.</DialogDescription>
+          </div>
+          {actions && <div className="flex flex-wrap items-center gap-2">{actions}</div>}
+        </div>
+        {purchaseInvoiceId !== null && (
+          <PurchaseInvoicePrintPreview purchaseInvoiceId={purchaseInvoiceId} refreshKey={refreshKey} className="flex-1" />
+        )}
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/Frontend/erp-system/components/products/BrandPanel.tsx b/Frontend/erp-system/components/products/BrandPanel.tsx
index 82df0b3..7a888ce 100644
--- a/Frontend/erp-system/components/products/BrandPanel.tsx
+++ b/Frontend/erp-system/components/products/BrandPanel.tsx
@@ -49,7 +49,10 @@ export function BrandPanel() {
   async function handleAdd() {
     const nextErrors = validateBrandName(name)
     setErrors(nextErrors)
-    if (Object.keys(nextErrors).length > 0) return
+    if (Object.keys(nextErrors).length > 0) {
+      toast.error("Could not create brand", Object.values(nextErrors)[0])
+      return
+    }
 
     setSubmitting(true)
     try {
@@ -91,7 +94,10 @@ export function BrandPanel() {
     if (!editing) return
     const nextErrors = validateBrandName(editName)
     setEditErrors(nextErrors)
-    if (Object.keys(nextErrors).length > 0) return
+    if (Object.keys(nextErrors).length > 0) {
+      toast.error("Could not update brand", Object.values(nextErrors)[0])
+      return
+    }
 
     setEditSubmitting(true)
     try {
@@ -116,7 +122,10 @@ export function BrandPanel() {
       <div className="flex flex-col gap-3 sm:flex-row sm:items-center">
         <Input
           value={name}
-          onChange={(e) => setName(e.target.value)}
+          onChange={(e) => {
+            setName(e.target.value)
+            setErrors({})
+          }}
           placeholder="New brand name, e.g. Bosch"
           className="h-12 flex-1 text-base"
           aria-label="New brand name"
@@ -178,11 +187,14 @@ export function BrandPanel() {
           </DialogHeader>
           <FieldGroup>
             <Field data-invalid={!!editErrors.name}>
-              <FieldLabel htmlFor="brand-edit-name">Name</FieldLabel>
+              <FieldLabel htmlFor="brand-edit-name" required>Name</FieldLabel>
               <Input
                 id="brand-edit-name"
                 value={editName}
-                onChange={(e) => setEditName(e.target.value)}
+                onChange={(e) => {
+                  setEditName(e.target.value)
+                  setEditErrors({})
+                }}
                 aria-invalid={!!editErrors.name}
               />
               <FieldError errors={[editErrors.name ? { message: editErrors.name } : undefined]} />
diff --git a/Frontend/erp-system/components/products/CategoryPanel.tsx b/Frontend/erp-system/components/products/CategoryPanel.tsx
index 14a618a..90c402a 100644
--- a/Frontend/erp-system/components/products/CategoryPanel.tsx
+++ b/Frontend/erp-system/components/products/CategoryPanel.tsx
@@ -23,6 +23,7 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { Skeleton } from "@/components/ui/skeleton"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { toast } from "@/components/ui/toast"
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
 
 type SortOrder = "asc" | "desc"
 type SortKey = "categoryId" | "name" | "status" | "createdAt"
@@ -145,7 +146,10 @@ export function CategoryPanel() {
   async function handleSubmit() {
     const nextErrors = validateCategoryName(name)
     setErrors(nextErrors)
-    if (Object.keys(nextErrors).length > 0) return
+    if (Object.keys(nextErrors).length > 0) {
+      toast.error(editing ? "Could not update category" : "Could not create category", Object.values(nextErrors)[0])
+      return
+    }
 
     setSubmitting(true)
     try {
@@ -219,8 +223,8 @@ export function CategoryPanel() {
             </DialogHeader>
             <FieldGroup>
               <Field data-invalid={!!errors.name}>
-                <FieldLabel htmlFor="cat-name">Name</FieldLabel>
-                <Input id="cat-name" value={name} onChange={(e) => setName(e.target.value)} placeholder="Fasteners" aria-invalid={!!errors.name} />
+                <FieldLabel htmlFor="cat-name" required>Name</FieldLabel>
+                <Input id="cat-name" value={name} onChange={(e) => { setName(e.target.value); setErrors({}) }} placeholder="Fasteners" aria-invalid={!!errors.name} />
                 <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
               </Field>
             </FieldGroup>
@@ -385,39 +389,45 @@ export function CategoryPanel() {
                           {/* Subcategories are their own resource now, not a nested tree.
                               Hidden while the feature is switched off in Product Configuration. */}
                           {config?.subcategoriesEnabled && (
-                            <Link
-                              href={`/dashboard/products/categories/${c.categoryId}`}
-                              className={cn(buttonVariants({ variant: "ghost", size: "icon-sm" }))}
-                              aria-label={`Manage subcategories of ${c.name}`}
-                            >
-                              <Network className="size-4" />
-                            </Link>
+                            <ActionTooltip label="Manage subcategories">
+                              <Link
+                                href={`/dashboard/products/categories/${c.categoryId}`}
+                                className={cn(buttonVariants({ variant: "ghost", size: "icon-sm" }))}
+                                aria-label={`Manage subcategories of ${c.name}`}
+                              >
+                                <Network className="size-4" />
+                              </Link>
+                            </ActionTooltip>
                           )}
 
-                          <Button
-                            variant="ghost"
-                            size="icon-sm"
-                            aria-label={`Edit ${c.name}`}
-                            onClick={() => openEditDialog(c)}
-                          >
-                            <Pencil className="size-4" />
-                          </Button>
+                          <ActionTooltip label="Edit">
+                            <Button
+                              variant="ghost"
+                              size="icon-sm"
+                              aria-label={`Edit ${c.name}`}
+                              onClick={() => openEditDialog(c)}
+                            >
+                              <Pencil className="size-4" />
+                            </Button>
+                          </ActionTooltip>
 
                           {/* Deactivate, not delete: no DELETE exists for any master (FR-MD-08). */}
                           <AlertDialog>
-                            <AlertDialogTrigger
-                              render={
-                                <Button
-                                  variant="ghost"
-                                  size="icon-sm"
-                                  className={c.status === "Active" ? "text-destructive hover:bg-destructive/10" : ""}
-                                  aria-label={`${c.status === "Active" ? "Deactivate" : "Activate"} ${c.name}`}
-                                  disabled={deletingId === c.categoryId}
-                                />
-                              }
-                            >
-                              {c.status === "Active" ? <Ban className="size-4" /> : <CheckCircle2 className="size-4" />}
-                            </AlertDialogTrigger>
+                            <ActionTooltip label={c.status === "Active" ? "Deactivate" : "Activate"}>
+                              <AlertDialogTrigger
+                                render={
+                                  <Button
+                                    variant="ghost"
+                                    size="icon-sm"
+                                    className={c.status === "Active" ? "text-destructive hover:bg-destructive/10" : ""}
+                                    aria-label={`${c.status === "Active" ? "Deactivate" : "Activate"} ${c.name}`}
+                                    disabled={deletingId === c.categoryId}
+                                  />
+                                }
+                              >
+                                {c.status === "Active" ? <Ban className="size-4" /> : <CheckCircle2 className="size-4" />}
+                              </AlertDialogTrigger>
+                            </ActionTooltip>
                             <AlertDialogContent
                               variant={c.status === "Active" ? "destructive" : "success"}
                               title={`${c.status === "Active" ? "Deactivate" : "Activate"} ${c.name}?`}
@@ -453,6 +463,16 @@ export function CategoryPanel() {
   )
 }
 
+/** Hover label for an icon-only row action; `children` becomes the tooltip trigger. */
+function ActionTooltip({ label, children }: { label: string; children: React.ReactElement }) {
+  return (
+    <Tooltip>
+      <TooltipTrigger render={children} />
+      <TooltipContent>{label}</TooltipContent>
+    </Tooltip>
+  )
+}
+
 function SortableHeader({
   label,
   active,
diff --git a/Frontend/erp-system/components/products/UomPanel.tsx b/Frontend/erp-system/components/products/UomPanel.tsx
index 23ec659..84c22e3 100644
--- a/Frontend/erp-system/components/products/UomPanel.tsx
+++ b/Frontend/erp-system/components/products/UomPanel.tsx
@@ -53,7 +53,10 @@ export function UomPanel() {
   async function handleAdd() {
     const nextErrors = validateUomName(name)
     setErrors(nextErrors)
-    if (Object.keys(nextErrors).length > 0) return
+    if (Object.keys(nextErrors).length > 0) {
+      toast.error("Could not create UOM", Object.values(nextErrors)[0])
+      return
+    }
 
     setSubmitting(true)
     try {
@@ -76,7 +79,10 @@ export function UomPanel() {
       <div className="flex flex-col gap-3 sm:flex-row sm:items-center">
         <Input
           value={name}
-          onChange={(e) => setName(e.target.value)}
+          onChange={(e) => {
+            setName(e.target.value)
+            setErrors({})
+          }}
           placeholder="New UOM name, e.g. Box-12"
           className="h-12 flex-1 text-base"
           aria-label="New UOM name"
diff --git a/Frontend/erp-system/components/sales/DayEndIncomeChart.tsx b/Frontend/erp-system/components/sales/DayEndIncomeChart.tsx
new file mode 100644
index 0000000..1a99124
--- /dev/null
+++ b/Frontend/erp-system/components/sales/DayEndIncomeChart.tsx
@@ -0,0 +1,76 @@
+"use client"
+
+import { CategoryScale, Chart as ChartJS, Legend, LinearScale, LineElement, PointElement, Tooltip } from "chart.js"
+import { useTheme } from "next-themes"
+import { Line } from "react-chartjs-2"
+
+import { formatAmount, formatReportDate, formatSignedAmount, profitOrLoss } from "@/lib/format"
+import { DayEndReportDay } from "@/types/sales"
+
+ChartJS.register(CategoryScale, LinearScale, PointElement, LineElement, Tooltip, Legend)
+
+// Categorical slots 1-4 of the validated chart palette, stepped per mode (not auto-flipped).
+const SERIES = {
+  light: { income: "#2a78d6", sales: "#eb6834", expenses: "#1baf7a", profit: "#eda100", grid: "rgba(0,0,0,0.08)", text: "#5f5e58" },
+  dark: { income: "#3987e5", sales: "#d95926", expenses: "#199e70", profit: "#c98500", grid: "rgba(255,255,255,0.1)", text: "#c3c2b7" },
+}
+
+/** Day-wise income and profit/loss lines (with sales and expenses beside them) — one shared amount axis, a shared
+ * index tooltip as the crosshair, legend on top. The day-wise table below the chart is its table view. */
+export function DayEndIncomeChart({ days }: { days: DayEndReportDay[] }) {
+  const { resolvedTheme } = useTheme()
+  const c = resolvedTheme === "dark" ? SERIES.dark : SERIES.light
+  const labels = days.map((d) => formatReportDate(d.date))
+
+  const line = (label: string, data: number[], color: string, width: number) => ({
+    label,
+    data,
+    borderColor: color,
+    backgroundColor: color,
+    borderWidth: width,
+    pointRadius: days.length > 45 ? 0 : 3,
+    pointHoverRadius: 5,
+    tension: 0.25,
+    fill: false,
+  })
+
+  return (
+    <div className="h-72 w-full">
+      <Line
+        data={{
+          labels,
+          datasets: [
+            line("Income", days.map((d) => d.income), c.income, 2.5),
+            line("Sales", days.map((d) => d.totalSales), c.sales, 2),
+            line("Expenses", days.map((d) => d.expenseTotal), c.expenses, 2),
+            line("Profit / loss", days.map((d) => d.netProfit), c.profit, 2.5),
+          ],
+        }}
+        options={{
+          responsive: true,
+          maintainAspectRatio: false,
+          interaction: { mode: "index", intersect: false },
+          plugins: {
+            legend: { position: "top", align: "start", labels: { color: c.text, usePointStyle: true, boxWidth: 8 } },
+            tooltip: {
+              callbacks: {
+                label: (ctx) => {
+                  const y = ctx.parsed.y ?? 0
+                  if (ctx.dataset.label === "Income")
+                    return y < 0 ? `Income: ${formatSignedAmount(y)} (loss)` : `Income: ${formatSignedAmount(y)}`
+                  if (ctx.dataset.label !== "Profit / loss") return `${ctx.dataset.label}: ${formatAmount(y)}`
+                  const p = profitOrLoss(y)
+                  return `${p.label}: ${p.amount}`
+                },
+              },
+            },
+          },
+          scales: {
+            x: { grid: { display: false }, ticks: { color: c.text, maxRotation: 0, autoSkip: true, maxTicksLimit: 10 } },
+            y: { grid: { color: c.grid }, ticks: { color: c.text, callback: (v) => formatAmount(Number(v)) } },
+          },
+        }}
+      />
+    </div>
+  )
+}
diff --git a/Frontend/erp-system/components/sales/LineTrackingPicker.tsx b/Frontend/erp-system/components/sales/LineTrackingPicker.tsx
new file mode 100644
index 0000000..43ac207
--- /dev/null
+++ b/Frontend/erp-system/components/sales/LineTrackingPicker.tsx
@@ -0,0 +1,249 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { Layers, ScanLine } from "lucide-react"
+
+import { trackingApi } from "@/lib/api/tracking"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
+import { errorMessage } from "@/lib/error-map"
+import { cn } from "@/lib/utils"
+import { AvailableBatch, AvailableSerial, SalesLineSerial } from "@/types/tracking"
+import { TrackingMode } from "@/types/master-data"
+
+import { Button } from "@/components/ui/button"
+import { Checkbox } from "@/components/ui/checkbox"
+import { Input } from "@/components/ui/input"
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover"
+
+export interface LineTrackingValue {
+  batchId: number | null
+  batchNo: string | null
+  serials: SalesLineSerial[]
+}
+
+interface Props {
+  itemId: number
+  warehouseId: number | null
+  trackingMode: TrackingMode | undefined
+  /** Units the line issues (qty + free qty) — a serial line needs exactly this many serials. */
+  units: number
+  value: LineTrackingValue
+  onChange: (next: LineTrackingValue) => void
+  disabled?: boolean
+}
+
+/**
+ * Batch / serial choice for one sales line (docs/ITEM_TRACKING_PLAN.md Phase 8).
+ * Serial items: pick exactly `units` in-stock serials (search, scan + Enter, or tick).
+ * Batch items: pin a batch, or leave "Auto (FEFO)" for posting to pick soonest-expiring first.
+ * Renders nothing for untracked items.
+ */
+export function LineTrackingPicker({ itemId, warehouseId, trackingMode, units, value, onChange, disabled }: Props) {
+  const { serialNumbersEnabled } = useTrackingSettings()
+  if (!itemId || !warehouseId || (trackingMode !== "Serial" && trackingMode !== "Batch")) return null
+  // Serial numbers switched off in Product Configuration: serial items are plain stock.
+  if (trackingMode === "Serial" && serialNumbersEnabled === false) return null
+  return trackingMode === "Serial" ? (
+    <SerialPicker itemId={itemId} warehouseId={warehouseId} units={units} value={value} onChange={onChange} disabled={disabled} />
+  ) : (
+    <BatchPicker itemId={itemId} warehouseId={warehouseId} value={value} onChange={onChange} disabled={disabled} />
+  )
+}
+
+function SerialPicker({
+  itemId, warehouseId, units, value, onChange, disabled,
+}: { itemId: number; warehouseId: number; units: number; value: LineTrackingValue; onChange: (v: LineTrackingValue) => void; disabled?: boolean }) {
+  const [open, setOpen] = useState(false)
+  const [query, setQuery] = useState("")
+  const [available, setAvailable] = useState<AvailableSerial[] | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    if (!open) return
+    let cancelled = false
+    trackingApi
+      .availableSerials(itemId, warehouseId)
+      .then((rows) => { if (!cancelled) { setAvailable(rows); setError(null) } })
+      .catch((err) => { if (!cancelled) setError(errorMessage(err)) })
+    return () => { cancelled = true }
+  }, [open, itemId, warehouseId])
+
+  const selected = value.serials
+  const selectedIds = new Set(selected.map((s) => s.serialId))
+  const complete = selected.length === units
+
+  function toggle(s: { serialId: number; serialNo: string }) {
+    const next = selectedIds.has(s.serialId)
+      ? selected.filter((x) => x.serialId !== s.serialId)
+      : [...selected, { serialId: s.serialId, serialNo: s.serialNo }]
+    onChange({ ...value, serials: next })
+  }
+
+  // Scan / type a serial and press Enter: exact (case-insensitive) match ticks it.
+  function addTyped() {
+    const term = query.trim().toLowerCase()
+    if (!term || !available) return
+    const match = available.find((s) => s.serialNo.toLowerCase() === term)
+    if (!match) {
+      setError(`Serial "${query.trim()}" is not in stock at this warehouse.`)
+      return
+    }
+    if (!selectedIds.has(match.serialId)) toggle(match)
+    setQuery("")
+    setError(null)
+  }
+
+  const shown = (available ?? []).filter((s) => !query.trim() || s.serialNo.toLowerCase().includes(query.trim().toLowerCase()))
+
+  // "Select all" ticks the listed (search-filtered) serials, but never more than the line still needs:
+  // a serial line must carry exactly `units` serials.
+  const unselectedShown = shown.filter((s) => !selectedIds.has(s.serialId))
+  const toAdd = unselectedShown.slice(0, Math.max(0, units - selected.length))
+
+  function selectAll() {
+    onChange({ ...value, serials: [...selected, ...toAdd.map((s) => ({ serialId: s.serialId, serialNo: s.serialNo }))] })
+  }
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger
+        render={
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            disabled={disabled}
+            className={cn("mt-1 h-7 gap-1 px-2 text-xs", complete ? "border-success/50 text-success" : "border-warning/60 text-warning")}
+          />
+        }
+      >
+        <ScanLine className="size-3.5" />
+        Serials {selected.length}/{units}
+      </PopoverTrigger>
+      <PopoverContent align="start" className="w-80 p-3">
+        <div className="flex flex-col gap-2">
+          <Input
+            autoFocus
+            value={query}
+            onChange={(e) => setQuery(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.preventDefault()
+                addTyped()
+              }
+            }}
+            placeholder="Scan or search a serial — Enter to add"
+            className="h-9 text-sm"
+          />
+          {error && <p className="text-xs text-destructive">{error}</p>}
+          <div className="flex items-center justify-between gap-2">
+            <p className={cn("text-xs", complete ? "text-success" : "text-muted-foreground")}>
+              {selected.length} of {units} selected
+            </p>
+            <Button
+              type="button"
+              variant="ghost"
+              size="sm"
+              className="h-7 px-2 text-xs"
+              disabled={toAdd.length === 0}
+              onClick={selectAll}
+              title={toAdd.length < unselectedShown.length ? `Only ${units} serial${units === 1 ? "" : "s"} needed for this line` : undefined}
+            >
+              {toAdd.length > 0 && toAdd.length < unselectedShown.length ? `Select first ${toAdd.length}` : "Select all"}
+            </Button>
+          </div>
+          <div className="max-h-60 overflow-y-auto rounded-md border">
+            {available === null && !error && <p className="p-3 text-xs text-muted-foreground">Loading…</p>}
+            {available !== null && shown.length === 0 && (
+              <p className="p-3 text-xs text-muted-foreground">No in-stock serials match.</p>
+            )}
+            {shown.map((s) => {
+              const checked = selectedIds.has(s.serialId)
+              const full = !checked && selected.length >= units
+              return (
+                <label
+                  key={s.serialId}
+                  className={cn("flex cursor-pointer items-center gap-2 px-3 py-1.5 text-sm hover:bg-muted/50", full && "cursor-not-allowed opacity-50")}
+                >
+                  <Checkbox checked={checked} disabled={full} onCheckedChange={() => toggle(s)} />
+                  <span className="font-mono">{s.serialNo}</span>
+                  {s.batchNo && <span className="ml-auto text-xs text-muted-foreground">{s.batchNo}</span>}
+                </label>
+              )
+            })}
+          </div>
+          {selected.length > 0 && (
+            <Button type="button" variant="ghost" size="sm" className="self-end text-xs" onClick={() => onChange({ ...value, serials: [] })}>
+              Clear selection
+            </Button>
+          )}
+        </div>
+      </PopoverContent>
+    </Popover>
+  )
+}
+
+function BatchPicker({
+  itemId, warehouseId, value, onChange, disabled,
+}: { itemId: number; warehouseId: number; value: LineTrackingValue; onChange: (v: LineTrackingValue) => void; disabled?: boolean }) {
+  const [open, setOpen] = useState(false)
+  const [batches, setBatches] = useState<AvailableBatch[] | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    if (!open) return
+    let cancelled = false
+    trackingApi
+      .availableBatches(itemId, warehouseId)
+      .then((rows) => { if (!cancelled) { setBatches(rows); setError(null) } })
+      .catch((err) => { if (!cancelled) setError(errorMessage(err)) })
+    return () => { cancelled = true }
+  }, [open, itemId, warehouseId])
+
+  function pick(batch: AvailableBatch | null) {
+    onChange({ ...value, batchId: batch?.batchId ?? null, batchNo: batch?.batchNo ?? null })
+    setOpen(false)
+  }
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger
+        render={<Button type="button" variant="outline" size="sm" disabled={disabled} className="mt-1 h-7 gap-1 px-2 text-xs" />}
+      >
+        <Layers className="size-3.5" />
+        {value.batchId ? `Batch ${value.batchNo ?? value.batchId}` : "Batch: auto (FEFO)"}
+      </PopoverTrigger>
+      <PopoverContent align="start" className="w-80 p-2">
+        <button
+          type="button"
+          onClick={() => pick(null)}
+          className={cn("flex w-full flex-col rounded-md px-3 py-2 text-left hover:bg-muted/50", !value.batchId && "bg-muted")}
+        >
+          <span className="text-sm font-medium">Auto (FEFO)</span>
+          <span className="text-xs text-muted-foreground">Soonest-expiring batches are issued first when posted.</span>
+        </button>
+        {error && <p className="px-3 py-2 text-xs text-destructive">{error}</p>}
+        {batches === null && !error && <p className="px-3 py-2 text-xs text-muted-foreground">Loading…</p>}
+        {batches?.filter((b) => b.batchId !== null).map((b) => (
+          <button
+            key={b.batchId}
+            type="button"
+            onClick={() => pick(b)}
+            className={cn("flex w-full items-center justify-between gap-2 rounded-md px-3 py-2 text-left hover:bg-muted/50", value.batchId === b.batchId && "bg-muted")}
+          >
+            <span className="flex flex-col">
+              <span className="font-mono text-sm">{b.batchNo}</span>
+              <span className={cn("text-xs", b.daysToExpiry !== null && b.daysToExpiry <= 30 ? "text-warning" : "text-muted-foreground")}>
+                {b.expiryDate ? `Expires ${b.expiryDate}${b.daysToExpiry !== null ? ` (${b.daysToExpiry}d)` : ""}` : "No expiry"}
+              </span>
+            </span>
+            <span className="text-xs tabular-nums text-muted-foreground">{b.qty}</span>
+          </button>
+        ))}
+        {batches !== null && batches.every((b) => b.batchId === null) && (
+          <p className="px-3 py-2 text-xs text-muted-foreground">No batches in stock at this warehouse.</p>
+        )}
+      </PopoverContent>
+    </Popover>
+  )
+}
diff --git a/Frontend/erp-system/components/sales/PaymentLinesEditor.tsx b/Frontend/erp-system/components/sales/PaymentLinesEditor.tsx
index ea8b66f..dc43307 100644
--- a/Frontend/erp-system/components/sales/PaymentLinesEditor.tsx
+++ b/Frontend/erp-system/components/sales/PaymentLinesEditor.tsx
@@ -10,8 +10,9 @@ import { FieldError } from "@/components/ui/field"
 import { Input } from "@/components/ui/input"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
 
-/** One split of a payment: how it was paid (the GL cash/bank account) and how much. */
-export type PaymentLine = { key: number; glBankAccountId: string; amount: string }
+/** One split of a payment: how it was paid (the GL cash/bank account) and how much. `method` is only
+ * used when the editor is given `methodOptions` (sales payments: cash vs card for the Day-End Report). */
+export type PaymentLine = { key: number; glBankAccountId: string; amount: string; method?: string }
 
 export const round2 = (n: number) => Math.round(n * 100) / 100
 
@@ -21,6 +22,12 @@ export function localToday(): string {
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
 }
 
+/** Sales payments' default method for an account — mirrors the backend's fallback: money into a Cash
+ * account is cash, into a Bank account a card payment. The user can still change it per line. */
+export function salesMethodForAccount(account: CashAndBankAccountDto): string {
+  return account.accountType === "Cash" ? "Cash" : "Card"
+}
+
 export function paymentLinesTotal(lines: PaymentLine[]): number {
   return round2(lines.reduce((sum, l) => sum + (Number(l.amount) || 0), 0))
 }
@@ -46,17 +53,28 @@ interface PaymentLinesEditorProps {
   /** What is owed — the fixed "Total"; Paid is the lines' sum and Remaining the difference. */
   balance: number
   errors: Record<string, string>
+  /** When given, each line also gets a payment-method select (value → label). */
+  methodOptions?: Record<string, string>
+  /** The method a line switches to when its account is picked (e.g. a Cash account ⇒ "Cash"). */
+  methodForAccount?: (account: CashAndBankAccountDto) => string
 }
 
 /** Payment type + paid amount rows (add/remove), with a Total / Paid amount / Remaining summary. */
-export function PaymentLinesEditor({ lines, onChange, accounts, balance, errors }: PaymentLinesEditorProps) {
+export function PaymentLinesEditor({ lines, onChange, accounts, balance, errors, methodOptions, methodForAccount }: PaymentLinesEditorProps) {
   const paid = paymentLinesTotal(lines)
   const remaining = round2(balance - paid)
+  const cols = methodOptions ? "grid-cols-[1fr_9rem_8rem_8rem]" : "grid-cols-[1fr_8rem_8rem]"
 
   function updateLine(key: number, patch: Partial<PaymentLine>) {
     onChange(lines.map((l) => (l.key === key ? { ...l, ...patch } : l)))
   }
 
+  function selectAccount(key: number, glBankAccountId: string) {
+    const account = accounts?.find((a) => String(a.accountId) === glBankAccountId)
+    const method = account && methodForAccount ? methodForAccount(account) : undefined
+    updateLine(key, method ? { glBankAccountId, method } : { glBankAccountId })
+  }
+
   function addLine() {
     // A new line starts with whatever is still unpaid, so a two-way split is one edit.
     const key = Math.max(-1, ...lines.map((l) => l.key)) + 1
@@ -65,16 +83,17 @@ export function PaymentLinesEditor({ lines, onChange, accounts, balance, errors
 
   return (
     <div className="flex flex-col gap-2">
-      <div className="grid grid-cols-[1fr_8rem_8rem] gap-2 text-sm font-medium">
+      <div className={`grid ${cols} gap-2 text-sm font-medium`}>
         <span>Payment type</span>
+        {methodOptions && <span>Method</span>}
         <span>Paid amount</span>
         <span />
       </div>
 
       {lines.map((line, idx) => (
-        <div key={line.key} className="grid grid-cols-[1fr_8rem_8rem] items-start gap-2">
+        <div key={line.key} className={`grid ${cols} items-start gap-2`}>
           <div>
-            <Select<string> value={line.glBankAccountId} onValueChange={(v) => updateLine(line.key, { glBankAccountId: v ?? "" })}>
+            <Select<string> value={line.glBankAccountId} onValueChange={(v) => selectAccount(line.key, v ?? "")}>
               <SelectTrigger
                 className="w-full text-base"
                 aria-label={`Payment type, line ${idx + 1}`}
@@ -92,6 +111,22 @@ export function PaymentLinesEditor({ lines, onChange, accounts, balance, errors
             </Select>
             <FieldError errors={[errors[`account-${line.key}`] ? { message: errors[`account-${line.key}`] } : undefined]} />
           </div>
+          {methodOptions && (
+            <div>
+              <Select<string> value={line.method ?? ""} onValueChange={(v) => updateLine(line.key, { method: v ?? undefined })}>
+                <SelectTrigger className="w-full text-base" aria-label={`Payment method, line ${idx + 1}`}>
+                  <SelectValue placeholder="Method" />
+                </SelectTrigger>
+                <SelectContent>
+                  {Object.entries(methodOptions).map(([value, label]) => (
+                    <SelectItem key={value} value={value} label={label} className="text-base">
+                      {label}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+          )}
           <div>
             <Input
               type="number"
diff --git a/Frontend/erp-system/components/sales/SalesInvoiceBulkPaymentDialog.tsx b/Frontend/erp-system/components/sales/SalesInvoiceBulkPaymentDialog.tsx
index 356b69d..8f0fabf 100644
--- a/Frontend/erp-system/components/sales/SalesInvoiceBulkPaymentDialog.tsx
+++ b/Frontend/erp-system/components/sales/SalesInvoiceBulkPaymentDialog.tsx
@@ -7,7 +7,7 @@ import { salesApi } from "@/lib/api/sales"
 import { errorMessage } from "@/lib/error-map"
 import { formatAmount } from "@/lib/format"
 import { CashAndBankAccountDto } from "@/types/general-ledger"
-import { SalesInvoicePayment, SalesInvoiceSummary } from "@/types/sales"
+import { SalesInvoicePayment, SalesInvoiceSummary, SalesPaymentMethod, salesPaymentMethodLabels } from "@/types/sales"
 
 import { Button } from "@/components/ui/button"
 import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
@@ -20,6 +20,7 @@ import {
   PaymentLinesEditor,
   paymentLinesTotal,
   round2,
+  salesMethodForAccount,
   validatePaymentLines,
 } from "@/components/sales/PaymentLinesEditor"
 
@@ -114,7 +115,11 @@ export function SalesInvoiceBulkPaymentDialog({ invoices, open, onOpenChange, on
     try {
       const payments = await salesApi.payInvoicesBulk({
         salesInvoiceIds: ordered.map((i) => i.salesInvoiceId),
-        lines: lines.map((l) => ({ amount: Number(l.amount), glBankAccountId: Number(l.glBankAccountId) })),
+        lines: lines.map((l) => ({
+          amount: Number(l.amount),
+          glBankAccountId: Number(l.glBankAccountId),
+          paymentMethod: l.method as SalesPaymentMethod | undefined,
+        })),
         reference: reference || undefined,
         paymentDate,
       })
@@ -135,7 +140,7 @@ export function SalesInvoiceBulkPaymentDialog({ invoices, open, onOpenChange, on
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="sm:max-w-xl">
+      <DialogContent className="sm:max-w-2xl">
         <DialogHeader>
           <DialogTitle>
             Pay {ordered.length} invoices — {customerName}
@@ -204,7 +209,15 @@ export function SalesInvoiceBulkPaymentDialog({ invoices, open, onOpenChange, on
             <Input id="bulk-pay-reference" value={reference} onChange={(e) => setReference(e.target.value)} />
           </Field>
 
-          <PaymentLinesEditor lines={lines} onChange={setLines} accounts={accounts} balance={balance} errors={errors} />
+          <PaymentLinesEditor
+            lines={lines}
+            onChange={setLines}
+            accounts={accounts}
+            balance={balance}
+            errors={errors}
+            methodOptions={salesPaymentMethodLabels}
+            methodForAccount={salesMethodForAccount}
+          />
         </FieldGroup>
 
         <DialogFooter>
diff --git a/Frontend/erp-system/components/sales/SalesInvoicePaymentDialog.tsx b/Frontend/erp-system/components/sales/SalesInvoicePaymentDialog.tsx
index 66ba452..7ca923b 100644
--- a/Frontend/erp-system/components/sales/SalesInvoicePaymentDialog.tsx
+++ b/Frontend/erp-system/components/sales/SalesInvoicePaymentDialog.tsx
@@ -7,14 +7,21 @@ import { salesApi } from "@/lib/api/sales"
 import { errorMessage } from "@/lib/error-map"
 import { formatAmount } from "@/lib/format"
 import { CashAndBankAccountDto } from "@/types/general-ledger"
-import { SalesInvoicePayment, SalesInvoiceStatus, SalesInvoiceSummary } from "@/types/sales"
+import { SalesInvoicePayment, SalesInvoiceStatus, SalesInvoiceSummary, SalesPaymentMethod, salesPaymentMethodLabels } from "@/types/sales"
 
 import { Button } from "@/components/ui/button"
 import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"
 import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
 import { Input } from "@/components/ui/input"
 import { toast } from "@/components/ui/toast"
-import { localToday, PaymentLine, PaymentLinesEditor, round2, validatePaymentLines } from "@/components/sales/PaymentLinesEditor"
+import {
+  localToday,
+  PaymentLine,
+  PaymentLinesEditor,
+  round2,
+  salesMethodForAccount,
+  validatePaymentLines,
+} from "@/components/sales/PaymentLinesEditor"
 
 interface SalesInvoicePaymentDialogProps {
   // SalesInvoiceSummary rather than the full SalesInvoice — every field this dialog touches
@@ -100,6 +107,7 @@ export function SalesInvoicePaymentDialog({ invoice, open, onOpenChange, onPaid
         const payment = await salesApi.payInvoice(invoice.salesInvoiceId, {
           amount: Number(line.amount),
           glBankAccountId: Number(line.glBankAccountId),
+          paymentMethod: line.method as SalesPaymentMethod | undefined,
           reference: reference || undefined,
           paymentDate,
         })
@@ -137,7 +145,7 @@ export function SalesInvoicePaymentDialog({ invoice, open, onOpenChange, onPaid
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="sm:max-w-xl">
+      <DialogContent className="sm:max-w-2xl">
         <DialogHeader>
           <DialogTitle>{isDraft ? "Confirm & pay" : "Pay"} invoice {invoice.invoiceNo}</DialogTitle>
         </DialogHeader>
@@ -179,7 +187,15 @@ export function SalesInvoicePaymentDialog({ invoice, open, onOpenChange, onPaid
             <Input id="inv-pay-reference" value={reference} onChange={(e) => setReference(e.target.value)} />
           </Field>
 
-          <PaymentLinesEditor lines={lines} onChange={setLines} accounts={accounts} balance={balance} errors={errors} />
+          <PaymentLinesEditor
+            lines={lines}
+            onChange={setLines}
+            accounts={accounts}
+            balance={balance}
+            errors={errors}
+            methodOptions={salesPaymentMethodLabels}
+            methodForAccount={salesMethodForAccount}
+          />
         </FieldGroup>
 
         <DialogFooter>
diff --git a/Frontend/erp-system/components/sales/SalesInvoicePrint.tsx b/Frontend/erp-system/components/sales/SalesInvoicePrint.tsx
index d877630..aea8d05 100644
--- a/Frontend/erp-system/components/sales/SalesInvoicePrint.tsx
+++ b/Frontend/erp-system/components/sales/SalesInvoicePrint.tsx
@@ -1,8 +1,6 @@
 "use client"
 
-import { ReactNode, useEffect, useRef, useState, useSyncExternalStore } from "react"
-import { createPortal } from "react-dom"
-import { Download, Loader2, Printer, Share2 } from "lucide-react"
+import { ReactNode, useEffect, useState } from "react"
 
 import { salesApi } from "@/lib/api/sales"
 import { customersApi } from "@/lib/api/customers"
@@ -10,55 +8,29 @@ import { companyProfileApi } from "@/lib/api/company-profile"
 import { invoiceTemplateConfigApi } from "@/lib/api/invoice-template-config"
 import { errorMessage } from "@/lib/error-map"
 import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
 import { Dialog, DialogContent, DialogDescription, DialogTitle } from "@/components/ui/dialog"
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
-import { Skeleton } from "@/components/ui/skeleton"
-import { toast } from "@/components/ui/toast"
+import {
+  A4_SHEET_CLASS,
+  ACCENT,
+  formatDate,
+  InvoicePreviewFrame,
+  money,
+  PaperSize,
+  printColorExact,
+  qty,
+  RECEIPT_SHEET_BASE_CLASS,
+  RECEIPT_SHEET_CLASS,
+  ReceiptRow,
+  ReceiptRule,
+  ReceiptWidth,
+  SectionTitle,
+  templateNotes,
+} from "@/components/invoice-template/InvoicePrintKit"
 import { CompanyProfile } from "@/types/company-profile"
 import { Customer } from "@/types/customers"
 import { InvoiceTemplateConfig } from "@/types/invoice-template"
 import { SalesInvoice, SalesInvoicePayment } from "@/types/sales"
 
-// Deep-red accent from the reference layout — used for the heading underlines and header rule.
-const ACCENT = "#8b1c24"
-
-type PaperSize = "A4" | "80mm" | "58mm"
-type ReceiptWidth = Exclude<PaperSize, "A4">
-
-const PAPER_SIZES: { value: PaperSize; label: string; hint: string }[] = [
-  { value: "A4", label: "A4", hint: "210 × 297 mm" },
-  { value: "80mm", label: "80mm receipt", hint: "Thermal roll" },
-  { value: "58mm", label: "58mm receipt", hint: "Small thermal roll" },
-]
-
-/** Sets the printer's page box — the browser print dialog picks this up as the paper size. */
-const PAGE_RULES: Record<PaperSize, string> = {
-  A4: "@page { size: A4; margin: 12mm; }",
-  "80mm": "@page { size: 80mm auto; margin: 3mm; }",
-  "58mm": "@page { size: 58mm auto; margin: 2mm; }",
-}
-
-/** Receipt sheet sizing per roll — 58mm gets tighter padding and a smaller font to fit ~32 chars a line. */
-const RECEIPT_SHEET_CLASS: Record<ReceiptWidth, string> = {
-  "80mm": "w-[80mm] px-[4mm] py-[5mm] text-[11px]",
-  "58mm": "w-[58mm] px-[2.5mm] py-[4mm] text-[9.5px]",
-}
-
-function money(n: number) {
-  return `Rs. ${n.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
-}
-
-function qty(n: number) {
-  return n.toLocaleString(undefined, { maximumFractionDigits: 3 })
-}
-
-/** dd/MM/yyyy, as on the reference invoice. */
-function formatDate(value: string | Date) {
-  const d = new Date(value)
-  return `${String(d.getDate()).padStart(2, "0")}/${String(d.getMonth() + 1).padStart(2, "0")}/${d.getFullYear()}`
-}
-
 /** Everything both layouts render, resolved once. */
 interface InvoiceDoc {
   invoice: SalesInvoice
@@ -72,26 +44,11 @@ interface InvoiceDoc {
   showBank: boolean
 }
 
-const printColorExact = { printColorAdjust: "exact", WebkitPrintColorAdjust: "exact" } as const
-
-/** Section heading with the short accent underline. */
-function SectionTitle({ children }: { children: React.ReactNode }) {
-  return (
-    <div className="mb-3">
-      <h2 className="text-base font-bold text-neutral-900">{children}</h2>
-      <div className="mt-1 h-0.5 w-16" style={{ backgroundColor: ACCENT }} />
-    </div>
-  )
-}
-
 function A4Sheet({ invoice, customer, payments, company, template, dueDate, notes, showLogo, showBank }: InvoiceDoc) {
   const t = invoice.totals
   return (
     // On screen: a true 210 × 297 mm page. In print the @page margin does the spacing.
-    <div
-      className="invoice-sheet mx-auto min-h-[297mm] w-[210mm] shrink-0 bg-white p-[12mm] text-sm text-neutral-800 shadow-md ring-1 ring-foreground/10 print:min-h-0 print:w-auto print:shadow-none print:ring-0"
-      style={printColorExact}
-    >
+    <div className={A4_SHEET_CLASS} style={printColorExact}>
       {/* Title + meta */}
       <div className="flex items-start justify-between gap-6">
         <div>
@@ -262,31 +219,11 @@ function A4Sheet({ invoice, customer, payments, company, template, dueDate, note
   )
 }
 
-/** Dashed divider used between receipt sections. */
-function ReceiptRule() {
-  return <div className="my-2 border-t border-dashed border-neutral-500" />
-}
-
-function ReceiptRow({ label, value, bold }: { label: string; value: string; bold?: boolean }) {
-  return (
-    <div className={cn("flex justify-between gap-2", bold && "font-bold text-black")}>
-      <span>{label}</span>
-      <span className="tabular-nums">{value}</span>
-    </div>
-  )
-}
-
 /** 80mm / 58mm thermal layout: one centred column, no fills (thermal heads print black only). */
 function ReceiptSheet({ invoice, customer, payments, company, template, dueDate, notes, showLogo, width }: InvoiceDoc & { width: ReceiptWidth }) {
   const t = invoice.totals
   return (
-    <div
-      className={cn(
-        "invoice-sheet mx-auto shrink-0 bg-white leading-snug text-neutral-900 shadow-md ring-1 ring-foreground/10 print:w-auto print:p-0 print:shadow-none print:ring-0",
-        RECEIPT_SHEET_CLASS[width]
-      )}
-      style={printColorExact}
-    >
+    <div className={cn(RECEIPT_SHEET_BASE_CLASS, RECEIPT_SHEET_CLASS[width])} style={printColorExact}>
       <div className="text-center">
         {showLogo && (
           // eslint-disable-next-line @next/next/no-img-element -- print view, no next/image optimization needed
@@ -405,9 +342,7 @@ function useInvoiceDoc(invoiceId: number, refreshKey = 0) {
           company,
           template,
           dueDate,
-          notes: [...(template?.termsAndConditions ?? "").split("\n"), ...(template?.footerNote ?? "").split("\n")]
-            .map((l) => l.trim())
-            .filter(Boolean),
+          notes: templateNotes(template?.termsAndConditions, template?.footerNote),
           showLogo: template?.logoPlacement !== "None" && !!company?.logoUrl,
           showBank: !!template?.showBankDetails && !!company && !!(company.bankName || company.accountNumber),
         })
@@ -424,186 +359,22 @@ function useInvoiceDoc(invoiceId: number, refreshKey = 0) {
   return { doc, error }
 }
 
-const subscribeNoop = () => () => {}
-
-/** True only on the client — the print copy is portalled into document.body. */
-function useIsClient() {
-  return useSyncExternalStore(subscribeNoop, () => true, () => false)
-}
-
-/** Paper width in mm — the PDF page is this wide; A4 is also 297mm tall (longer invoices add pages). */
-const PAPER_WIDTH_MM: Record<PaperSize, number> = { A4: 210, "80mm": 80, "58mm": 58 }
-const A4_HEIGHT_MM = 297
-
-/**
- * Renders the on-screen sheet to a PDF that looks exactly like the preview: the sheet is captured
- * as an image (html-to-image) and laid onto pages of the chosen paper size (jsPDF). A4 is split
- * across as many 297mm pages as needed; a receipt is one page as long as the receipt itself.
- * Both libraries are loaded on demand.
- */
-async function buildInvoicePdf(sheet: HTMLElement, size: PaperSize): Promise<Blob> {
-  const [{ toPng }, { jsPDF }] = await Promise.all([import("html-to-image"), import("jspdf")])
-  // The sheet's drop shadow / ring are screen decoration only.
-  const dataUrl = await toPng(sheet, {
-    pixelRatio: 2,
-    backgroundColor: "#ffffff",
-    style: { boxShadow: "none", margin: "0" },
-    // A logo the browser can't read back (cross-origin, no CORS) becomes a blank instead of failing the whole PDF.
-    imagePlaceholder: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
-  })
-  const img = new Image()
-  img.src = dataUrl
-  await img.decode()
-
-  const widthMm = PAPER_WIDTH_MM[size]
-  const imgHeightMm = (img.height * widthMm) / img.width
-  if (size !== "A4") {
-    const pdf = new jsPDF({ unit: "mm", format: [widthMm, imgHeightMm] })
-    pdf.addImage(dataUrl, "PNG", 0, 0, widthMm, imgHeightMm)
-    return pdf.output("blob")
-  }
-  const pdf = new jsPDF({ unit: "mm", format: "a4" })
-  // Same image on every page, shifted up one page-height each time; the page box crops the rest.
-  for (let offset = 0, page = 0; offset < imgHeightMm - 0.5; offset += A4_HEIGHT_MM, page++) {
-    if (page > 0) pdf.addPage()
-    pdf.addImage(dataUrl, "PNG", 0, -offset, widthMm, imgHeightMm)
-  }
-  return pdf.output("blob")
-}
-
-function saveBlob(blob: Blob, filename: string) {
-  const url = URL.createObjectURL(blob)
-  const a = document.createElement("a")
-  a.href = url
-  a.download = filename
-  a.click()
-  setTimeout(() => URL.revokeObjectURL(url), 1000)
-}
-
 function Sheet({ size, doc }: { size: PaperSize; doc: InvoiceDoc }) {
   return size === "A4" ? <A4Sheet {...doc} /> : <ReceiptSheet {...doc} width={size} />
 }
 
-/**
- * Invoice preview + paper-size bar underneath + Print. Printing uses a copy of the sheet
- * portalled straight into <body> (`.invoice-print-root`, see globals.css) so the printout is
- * just the invoice, whether this is rendered in a page or inside a dialog.
- */
+/** Invoice preview + paper-size bar underneath + Share / Download / Print (see InvoicePreviewFrame). */
 export function SalesInvoicePrintPreview({ invoiceId, className, refreshKey }: { invoiceId: number; className?: string; refreshKey?: number }) {
   const { doc, error } = useInvoiceDoc(invoiceId, refreshKey)
-  const [paperSize, setPaperSize] = useState<PaperSize>("A4")
-  const isClient = useIsClient()
-  const previewRef = useRef<HTMLDivElement>(null)
-  const [busy, setBusy] = useState<"download" | "share" | null>(null)
-
-  const fileName = `${doc?.invoice.invoiceNo ?? `invoice-${invoiceId}`}${paperSize === "A4" ? "" : `-${paperSize}`}.pdf`
-
-  async function makePdf(): Promise<Blob> {
-    const sheet = previewRef.current?.querySelector<HTMLElement>(".invoice-sheet")
-    if (!sheet) throw new Error("The invoice is still loading.")
-    return buildInvoicePdf(sheet, paperSize)
-  }
-
-  async function handleDownload() {
-    setBusy("download")
-    try {
-      saveBlob(await makePdf(), fileName)
-    } catch (err) {
-      toast.error("Could not create the PDF", errorMessage(err))
-    } finally {
-      setBusy(null)
-    }
-  }
-
-  // Shares the PDF itself where the device supports sharing files (phones, most desktop Chrome/Edge);
-  // otherwise shares — or, failing that, copies — a link to this invoice's print page.
-  async function handleShare() {
-    const title = `Invoice ${doc?.invoice.invoiceNo ?? ""}`.trim()
-    const link = `${window.location.origin}/dashboard/sales/invoices/${invoiceId}/print`
-    setBusy("share")
-    try {
-      const file = new File([await makePdf()], fileName, { type: "application/pdf" })
-      if (navigator.canShare?.({ files: [file] })) {
-        await navigator.share({ files: [file], title, text: title })
-      } else if (navigator.share) {
-        await navigator.share({ title, text: title, url: link })
-      } else {
-        await navigator.clipboard.writeText(link)
-        toast.success("Link copied", "Sharing files isn't supported here — the invoice link is on your clipboard.")
-      }
-    } catch (err) {
-      // Closing the share sheet isn't an error.
-      if (!(err instanceof DOMException && err.name === "AbortError")) toast.error("Could not share the invoice", errorMessage(err))
-    } finally {
-      setBusy(null)
-    }
-  }
-
-  if (error && !doc) {
-    return <div className="m-4 rounded-lg border border-destructive/30 bg-destructive/5 p-5 text-base text-destructive">{error}</div>
-  }
-
   return (
-    <div className={cn("flex min-h-0 flex-col", className)}>
-      {/* Preview window — scrolls so the page keeps its true size. */}
-      <div ref={previewRef} className="min-h-0 flex-1 overflow-auto bg-muted/40 p-4 sm:p-6">
-        {doc ? (
-          <Sheet size={paperSize} doc={doc} />
-        ) : (
-          <Skeleton className="mx-auto h-[297mm] w-[210mm] max-w-full" />
-        )}
-      </div>
-
-      {/* Paper size selection, under the invoice. */}
-      <div className="flex flex-col gap-3 border-t bg-card p-4 sm:flex-row sm:items-center sm:justify-between">
-        <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:gap-3">
-          <label htmlFor="invoice-paper-size" className="text-sm font-semibold text-foreground">Paper size</label>
-          <Select<PaperSize>
-            value={paperSize}
-            onValueChange={(v) => v && setPaperSize(v)}
-            items={PAPER_SIZES.map((s) => ({ value: s.value, label: s.label }))}
-          >
-            <SelectTrigger id="invoice-paper-size" className="h-10! w-56 text-sm">
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              {PAPER_SIZES.map((s) => (
-                <SelectItem key={s.value} value={s.value}>
-                  <span className="flex flex-col">
-                    <span className="text-sm font-medium">{s.label}</span>
-                    <span className="text-xs text-muted-foreground">{s.hint}</span>
-                  </span>
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-        </div>
-        <div className="flex flex-wrap gap-2">
-          <Button size="lg" variant="outline" onClick={handleShare} disabled={!doc || busy !== null}>
-            {busy === "share" ? <Loader2 className="size-4 animate-spin" /> : <Share2 className="size-4" />}
-            Share
-          </Button>
-          <Button size="lg" variant="outline" onClick={handleDownload} disabled={!doc || busy !== null}>
-            {busy === "download" ? <Loader2 className="size-4 animate-spin" /> : <Download className="size-4" />}
-            Download
-          </Button>
-          <Button size="lg" onClick={() => window.print()} disabled={!doc}>
-            <Printer className="size-4" />
-            Print {paperSize === "A4" ? "A4" : `${paperSize} receipt`}
-          </Button>
-        </div>
-      </div>
-
-      {isClient &&
-        doc &&
-        createPortal(
-          <div className="invoice-print-root">
-            <style>{PAGE_RULES[paperSize]}</style>
-            <Sheet size={paperSize} doc={doc} />
-          </div>,
-          document.body
-        )}
-    </div>
+    <InvoicePreviewFrame
+      renderSheet={doc ? (size) => <Sheet size={size} doc={doc} /> : null}
+      error={error}
+      docNo={doc?.invoice.invoiceNo ?? `invoice-${invoiceId}`}
+      shareTitle={`Invoice ${doc?.invoice.invoiceNo ?? ""}`.trim()}
+      sharePath={`/dashboard/sales/invoices/${invoiceId}/print`}
+      className={className}
+    />
   )
 }
 
diff --git a/Frontend/erp-system/components/sales/SalesReturnForm.tsx b/Frontend/erp-system/components/sales/SalesReturnForm.tsx
index 2ff06e8..d6cf7c6 100644
--- a/Frontend/erp-system/components/sales/SalesReturnForm.tsx
+++ b/Frontend/erp-system/components/sales/SalesReturnForm.tsx
@@ -8,9 +8,10 @@ import { reasonCodesApi } from "@/lib/api/reason-codes"
 import { itemsApi } from "@/lib/api/items"
 import { errorMessage } from "@/lib/error-map"
 import { validateSalesReturnLine } from "@/lib/validations/sales"
-import { CreateSalesReturnLineInput, SalesInvoice, SalesInvoiceLine } from "@/types/sales"
+import { CreateSalesReturnLineInput, SalesInvoice, SalesInvoiceLine, SalesLineAllocation } from "@/types/sales"
 import { ItemListItem } from "@/types/master-data"
 import { ReasonCode } from "@/types/stock"
+import { useTrackingSettings } from "@/hooks/use-tracking-settings"
 
 import { Button } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
@@ -25,6 +26,10 @@ import { toast } from "@/components/ui/toast"
 interface LineState {
   selected: boolean
   qty: string
+  /** Serial line: the sold serials being returned (qty follows the count). */
+  serialIds?: number[]
+  /** Line that issued several batches: which one comes back. */
+  batchId?: number | null
 }
 
 export interface SalesReturnFormProps {
@@ -43,7 +48,10 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
   const [reasonCodes, setReasonCodes] = useState<ReasonCode[]>([])
   const [loadError, setLoadError] = useState<string | null>(null)
   const [remainingByLine, setRemainingByLine] = useState<Record<number, number>>({})
+  const [allocationsByLine, setAllocationsByLine] = useState<Record<number, SalesLineAllocation[]>>({})
   const [remainingLoading, setRemainingLoading] = useState(false)
+  const [markDamaged, setMarkDamaged] = useState(false)
+  const { serialNumbersEnabled } = useTrackingSettings()
 
   const [invoiceId, setInvoiceId] = useState<number | null>(presetInvoiceId)
   const [reasonCodeId, setReasonCodeId] = useState<number | null>(null)
@@ -83,8 +91,13 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
       .getRemaining(selectedInvoice.salesInvoiceId)
       .then((rows) => {
         const map: Record<number, number> = {}
-        for (const row of rows) map[row.salesInvoiceLineId] = row.remainingQty
+        const allocations: Record<number, SalesLineAllocation[]> = {}
+        for (const row of rows) {
+          map[row.salesInvoiceLineId] = row.remainingQty
+          allocations[row.salesInvoiceLineId] = row.allocations ?? []
+        }
         setRemainingByLine(map)
+        setAllocationsByLine(allocations)
         if (presetLineId) {
           const remaining = map[presetLineId] ?? 0
           setLineState((prev) => ({ ...prev, [presetLineId]: { selected: remaining > 0, qty: remaining > 0 ? String(remaining) : "" } }))
@@ -115,6 +128,74 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
     setLineState((prev) => ({ ...prev, [lineId]: { ...prev[lineId], qty } }))
   }
 
+  /** Sold serials of a line not yet returned — non-empty means the line is serial-tracked. */
+  function returnableSerials(lineId: number) {
+    if (serialNumbersEnabled === false) return [] // switched off: serial items return as plain stock
+    return (allocationsByLine[lineId] ?? []).filter((a) => a.serialId !== null && a.qtyReturned < a.qty)
+  }
+
+  /** Distinct batches a line issued that still have returnable qty. */
+  function returnableBatches(lineId: number) {
+    const seen = new Map<number, SalesLineAllocation>()
+    for (const a of allocationsByLine[lineId] ?? [])
+      if (a.batchId !== null && a.serialId === null && a.qtyReturned < a.qty && !seen.has(a.batchId)) seen.set(a.batchId, a)
+    return [...seen.values()]
+  }
+
+  function toggleSerial(lineId: number, serialId: number) {
+    setLineState((prev) => {
+      const current = prev[lineId]?.serialIds ?? []
+      const next = current.includes(serialId) ? current.filter((id) => id !== serialId) : [...current, serialId]
+      return { ...prev, [lineId]: { ...prev[lineId], selected: next.length > 0, serialIds: next, qty: String(next.length) } }
+    })
+  }
+
+  /** Serial checkboxes or batch choice under a line, when the sale recorded either. */
+  function renderLineTracking(line: SalesInvoiceLine) {
+    const lineId = line.salesInvoiceLineId
+    const serials = returnableSerials(lineId)
+    const batches = returnableBatches(lineId)
+    const state = lineState[lineId]
+    if (serials.length > 0) {
+      return (
+        <div className="mt-2 flex flex-col gap-1">
+          <p className="text-xs text-muted-foreground">Tick the serials coming back:</p>
+          <div className="flex flex-wrap gap-x-4 gap-y-1">
+            {serials.map((s) => (
+              <label key={s.serialId} className="flex items-center gap-1.5 text-sm">
+                <Checkbox checked={state?.serialIds?.includes(s.serialId!) ?? false} onCheckedChange={() => toggleSerial(lineId, s.serialId!)} />
+                <span className="font-mono">{s.serialNo}</span>
+              </label>
+            ))}
+          </div>
+        </div>
+      )
+    }
+    if (batches.length > 1 && state?.selected) {
+      return (
+        <div className="mt-2 max-w-64">
+          <Select<number | null>
+            value={state.batchId ?? null}
+            onValueChange={(v) => setLineState((prev) => ({ ...prev, [lineId]: { ...prev[lineId], batchId: v } }))}
+          >
+            <SelectTrigger className="h-9! w-full text-sm">
+              <SelectValue placeholder="Which batch comes back?" />
+            </SelectTrigger>
+            <SelectContent>
+              {batches.map((b) => (
+                <SelectItem key={b.batchId} value={b.batchId} className="text-sm">
+                  {b.batchNo}{b.expiryDate ? ` · exp ${b.expiryDate}` : ""}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+      )
+    }
+    if (batches.length === 1) return <p className="mt-1 text-xs text-muted-foreground">Batch {batches[0].batchNo}</p>
+    return null
+  }
+
   async function handleSubmit() {
     setHeaderError(null)
     setSubmitError(null)
@@ -141,6 +222,11 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
         qty: lineState[line.salesInvoiceLineId].qty,
         maxQty: remainingFor(line.salesInvoiceLineId, line.qty),
       })
+      const state = lineState[line.salesInvoiceLineId]
+      if (returnableSerials(line.salesInvoiceLineId).length > 0 && (state.serialIds?.length ?? 0) !== Number(state.qty))
+        errors.qty = "Tick one serial per unit returned"
+      if (returnableBatches(line.salesInvoiceLineId).length > 1 && !state.batchId)
+        errors.qty = "Choose which batch comes back"
       if (Object.keys(errors).length > 0) nextErrors[line.salesInvoiceLineId] = errors
     }
     setLineErrors(nextErrors)
@@ -153,6 +239,8 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
       salesInvoiceLineId: l.salesInvoiceLineId,
       itemId: l.itemId,
       qty: Number(lineState[l.salesInvoiceLineId].qty),
+      batchId: lineState[l.salesInvoiceLineId].batchId ?? null,
+      serialIds: lineState[l.salesInvoiceLineId].serialIds?.length ? lineState[l.salesInvoiceLineId].serialIds : null,
     }))
 
     setSubmitting(true)
@@ -161,6 +249,7 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
         customerId: selectedInvoice.customerId,
         warehouseId: selectedInvoice.warehouseId,
         reasonCodeId,
+        markDamaged: markDamaged || null,
         lines: payloadLines,
       })
       toast.success("Sales return posted", `${salesReturn.docNo} — ${salesReturn.ledgerRefs.length} ledger entr${salesReturn.ledgerRefs.length === 1 ? "y" : "ies"} posted.`)
@@ -216,6 +305,10 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
                 </SelectContent>
               </Select>
             </div>
+            <label className="flex items-center gap-2 text-sm text-muted-foreground">
+              <Checkbox checked={markDamaged} onCheckedChange={(v) => setMarkDamaged(!!v)} />
+              Returned serials are damaged (not resaleable) — Defective / Quality Reject reasons imply this
+            </label>
           </div>
 
           {headerError && (
@@ -242,6 +335,7 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
                           {item ? `${item.sku} — ${item.name}` : line.description}
                         </span>
                       </label>
+                      {renderLineTracking(line)}
 
                       <div className="grid grid-cols-3 gap-3 border-t pt-3 text-sm">
                         <div>
@@ -305,7 +399,10 @@ export function SalesReturnForm({ presetInvoiceId = null, presetLineId = null, o
                           <TableCell>
                             <Checkbox checked={state.selected} disabled={fullyReturned} onCheckedChange={() => toggleLine(line)} />
                           </TableCell>
-                          <TableCell>{item ? `${item.sku} — ${item.name}` : line.description}</TableCell>
+                          <TableCell>
+                            {item ? `${item.sku} — ${item.name}` : line.description}
+                            {renderLineTracking(line)}
+                          </TableCell>
                           <TableCell className="text-sm text-muted-foreground">{line.qty}</TableCell>
                           <TableCell className="text-sm text-muted-foreground">
                             {remainingLoading ? "…" : fullyReturned ? <span>Fully returned</span> : remaining}
diff --git a/Frontend/erp-system/components/stock/status-badges.tsx b/Frontend/erp-system/components/stock/status-badges.tsx
index f3ea780..a84e957 100644
--- a/Frontend/erp-system/components/stock/status-badges.tsx
+++ b/Frontend/erp-system/components/stock/status-badges.tsx
@@ -26,10 +26,24 @@ export function CountStatusBadge({ status }: { status: CountStatus }) {
   )
 }
 
+const adjustmentLabel: Record<AdjustmentStatus, string> = {
+  Draft: "Draft",
+  PendingApproval: "Pending",
+  PendingSecondApproval: "Pending 2nd",
+  Posted: "Posted",
+  Rejected: "Rejected",
+  Cancelled: "Withdrawn",
+}
+
 export function AdjustmentStatusBadge({ status }: { status: AdjustmentStatus }) {
+  const tone =
+    status === "Posted" ? success
+    : status === "Rejected" ? destructive
+    : status === "Cancelled" ? "bg-muted text-muted-foreground border-transparent"
+    : warning
   return (
-    <Badge variant="outline" className={`${badgeSize} ${success}`}>
-      {status}
+    <Badge variant="outline" className={`${badgeSize} ${tone}`}>
+      {adjustmentLabel[status]}
     </Badge>
   )
 }
diff --git a/Frontend/erp-system/components/ui/bar-chart.tsx b/Frontend/erp-system/components/ui/bar-chart.tsx
index 92232bd..84806b6 100644
--- a/Frontend/erp-system/components/ui/bar-chart.tsx
+++ b/Frontend/erp-system/components/ui/bar-chart.tsx
@@ -35,7 +35,8 @@ type Props = {
   labels: string[]
   datasets: Array<{
     label?: string
-    data: number[]
+    /** `null` leaves an empty slot — used to pad the axis so a few bars sit at the start. */
+    data: (number | null)[]
     backgroundColor?: string | string[]
   }>
   /** Container height in px — defaults to the original 260 so existing callers are unaffected. */
diff --git a/Frontend/erp-system/components/ui/label.tsx b/Frontend/erp-system/components/ui/label.tsx
index 74da65c..36a64c3 100644
--- a/Frontend/erp-system/components/ui/label.tsx
+++ b/Frontend/erp-system/components/ui/label.tsx
@@ -4,7 +4,13 @@ import * as React from "react"
 
 import { cn } from "@/lib/utils"
 
-function Label({ className, ...props }: React.ComponentProps<"label">) {
+/** `required` appends a red asterisk to mark a mandatory field. */
+function Label({
+  className,
+  required,
+  children,
+  ...props
+}: React.ComponentProps<"label"> & { required?: boolean }) {
   return (
     <label
       data-slot="label"
@@ -13,7 +19,14 @@ function Label({ className, ...props }: React.ComponentProps<"label">) {
         className
       )}
       {...props}
-    />
+    >
+      {children}
+      {required && (
+        <span aria-hidden="true" className="-ml-1 text-destructive">
+          *
+        </span>
+      )}
+    </label>
   )
 }
 
diff --git a/Frontend/erp-system/components/ui/suggest-input.tsx b/Frontend/erp-system/components/ui/suggest-input.tsx
index c6ecf5d..99496b8 100644
--- a/Frontend/erp-system/components/ui/suggest-input.tsx
+++ b/Frontend/erp-system/components/ui/suggest-input.tsx
@@ -17,6 +17,8 @@ export interface SuggestOption {
   /** Optional pill shown on the right, before the hint (e.g. an available stock count). */
   badge?: string
   badgeTone?: SuggestBadgeTone
+  /** Optional highlighted pills right after the label (e.g. "Serial" / "Batch" tracking). */
+  tags?: { label: string; tone: SuggestTagTone }[]
 }
 
 export type SuggestBadgeTone = "muted" | "success" | "danger"
@@ -27,6 +29,29 @@ const badgeToneClass: Record<SuggestBadgeTone, string> = {
   danger: "bg-destructive/10 text-destructive",
 }
 
+export type SuggestTagTone = "serial" | "batch"
+
+const tagToneClass: Record<SuggestTagTone, string> = {
+  serial: "border-sky-500/40 bg-sky-500/15 text-sky-700 dark:text-sky-300",
+  batch: "border-amber-500/40 bg-amber-500/15 text-amber-700 dark:text-amber-300",
+}
+
+function OptionLabel({ option }: { option: SuggestOption }) {
+  return (
+    <span className="flex min-w-0 items-center gap-1.5">
+      <span className="truncate">{option.label}</span>
+      {option.tags?.map((tag) => (
+        <span
+          key={tag.label}
+          className={cn("shrink-0 rounded-md border px-1.5 py-px text-[11px] font-semibold uppercase tracking-wide", tagToneClass[tag.tone])}
+        >
+          {tag.label}
+        </span>
+      ))}
+    </span>
+  )
+}
+
 interface SuggestInputProps {
   options: SuggestOption[]
   /** Called with the picked option's value; the box then clears for the next entry. */
@@ -259,11 +284,11 @@ export function SuggestInput({
               >
                 {option.detail ? (
                   <span className="flex min-w-0 flex-col">
-                    <span className="truncate">{option.label}</span>
+                    <OptionLabel option={option} />
                     <span className="truncate text-xs text-muted-foreground">{option.detail}</span>
                   </span>
                 ) : (
-                  <span className="truncate">{option.label}</span>
+                  <OptionLabel option={option} />
                 )}
                 {(option.badge || option.hint) && (
                   <span className="flex shrink-0 items-center gap-2">
diff --git a/Frontend/erp-system/components/vendors/EditVendorDialog.tsx b/Frontend/erp-system/components/vendors/EditVendorDialog.tsx
new file mode 100644
index 0000000..dd0e058
--- /dev/null
+++ b/Frontend/erp-system/components/vendors/EditVendorDialog.tsx
@@ -0,0 +1,185 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+import { vendorsApi } from "@/lib/api/vendors"
+import { errorMessage, fieldErrors } from "@/lib/error-map"
+import { generateVendorCode } from "@/lib/vendor-code"
+import { Vendor } from "@/types/master-data"
+
+import { Button } from "@/components/ui/button"
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from "@/components/ui/dialog"
+import { Field, FieldError, FieldGroup, FieldLabel } from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Skeleton } from "@/components/ui/skeleton"
+import { toast } from "@/components/ui/toast"
+
+/**
+ * Edit popup for one vendor, opened from the vendors list. Mount it with `key={vendorId}`
+ * so each open starts clean. The list rows carry no ETag, so the vendor is re-read here
+ * for a fresh If-Match before anything can be saved.
+ */
+export function EditVendorDialog({
+  vendorId,
+  existingCodes,
+  onClose,
+  onSaved,
+}: {
+  vendorId: number
+  /** Every loaded vendor code, to de-dupe the regenerated code against (this vendor's own is skipped). */
+  existingCodes: string[]
+  onClose: () => void
+  onSaved: (vendor: Vendor) => void
+}) {
+  const [vendor, setVendor] = useState<Vendor | null>(null)
+  const [etag, setEtag] = useState<string | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+
+  const [code, setCode] = useState("")
+  const [name, setName] = useState("")
+  const [terms, setTerms] = useState("")
+  const [taxReg, setTaxReg] = useState("")
+  const [currency, setCurrency] = useState("")
+  const [errors, setErrors] = useState<Record<string, string>>({})
+  const [saving, setSaving] = useState(false)
+
+  function applyVendor(data: Vendor, tag: string | null) {
+    setVendor(data)
+    setEtag(tag)
+    setCode(data.code)
+    setName(data.name)
+    setTerms(data.terms ?? "")
+    setTaxReg(data.taxReg ?? "")
+    setCurrency(data.currency)
+  }
+
+  function reload() {
+    return vendorsApi.get(vendorId).then(({ data, etag: tag }) => applyVendor(data, tag))
+  }
+
+  useEffect(() => {
+    reload().catch((err) => setLoadError(errorMessage(err)))
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [vendorId])
+
+  /** Drops fields' errors once the user starts editing them. */
+  function clearErrors(...keys: string[]) {
+    setErrors((prev) => {
+      if (!keys.some((k) => prev[k])) return prev
+      const next = { ...prev }
+      for (const k of keys) delete next[k]
+      return next
+    })
+  }
+
+  function handleNameChange(value: string) {
+    setName(value)
+    const otherCodes = existingCodes.filter((c) => c !== vendor?.code)
+    setCode(value.trim() ? generateVendorCode(value, otherCodes) : "")
+    // The code is regenerated from the name, so its error is stale too.
+    clearErrors("name", "code")
+  }
+
+  async function handleSave() {
+    const nextErrors: Record<string, string> = {}
+    if (!code.trim()) nextErrors.code = "Vendor code is required"
+    if (!name.trim()) nextErrors.name = "Vendor name is required"
+    if (!currency.trim()) nextErrors.currency = "Currency is required"
+    setErrors(nextErrors)
+    if (Object.keys(nextErrors).length > 0) {
+      toast.error("Could not save vendor", Object.values(nextErrors)[0])
+      return
+    }
+    if (!vendor || !etag) return
+
+    setSaving(true)
+    try {
+      const result = await vendorsApi.update(
+        vendorId,
+        { code, name, terms: terms || null, taxReg: taxReg || null, currency, branchId: vendor.branchId },
+        etag
+      )
+      toast.success("Vendor saved", `${result.data.code} — ${result.data.name}`)
+      onSaved(result.data)
+    } catch (err) {
+      if ((err as { code?: string })?.code === "CONCURRENCY_CONFLICT") {
+        // Someone else saved first: show their version so the user can redo the edit on top of it.
+        toast.error("Vendor was changed by someone else", "The latest details have been loaded — make your edit again.")
+        await reload().catch(() => {})
+        return
+      }
+      const fe = fieldErrors(err)
+      if (fe?.code) setErrors({ code: fe.code })
+      toast.error("Could not save vendor", errorMessage(err))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  // Laid out to match the "New vendor" dialog (app/dashboard/vendors/page.tsx).
+  return (
+    <Dialog open onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader className="items-center text-center">
+          <DialogTitle>Edit vendor</DialogTitle>
+          <DialogDescription>Update this supplier record. Its code is regenerated from the name.</DialogDescription>
+        </DialogHeader>
+
+        {loadError ? (
+          <div className="rounded-lg border border-destructive/30 bg-destructive/5 p-4 text-base text-destructive">{loadError}</div>
+        ) : !vendor ? (
+          <div className="flex flex-col gap-5">
+            {Array.from({ length: 5 }).map((_, i) => (
+              <Skeleton key={i} className="h-14 w-full" />
+            ))}
+          </div>
+        ) : (
+          <FieldGroup>
+            <Field data-invalid={!!errors.name}>
+              <FieldLabel htmlFor="ev-name" required>Name</FieldLabel>
+              <Input id="ev-name" value={name} onChange={(e) => handleNameChange(e.target.value)} placeholder="Lanka Steel Traders (Pvt) Ltd" aria-invalid={!!errors.name} />
+              <FieldError errors={[errors.name ? { message: errors.name } : undefined]} />
+            </Field>
+            <Field data-invalid={!!errors.code}>
+              <FieldLabel htmlFor="ev-code">Code (auto-generated)</FieldLabel>
+              <Input id="ev-code" value={code} readOnly disabled placeholder="Enter a name to generate a code" className="text-muted-foreground" />
+              <FieldError errors={[errors.code ? { message: errors.code } : undefined]} />
+            </Field>
+            <Field>
+              <FieldLabel htmlFor="ev-terms">Payment terms (optional)</FieldLabel>
+              <Input id="ev-terms" value={terms} onChange={(e) => setTerms(e.target.value)} placeholder="NET30" />
+            </Field>
+            <Field>
+              <FieldLabel htmlFor="ev-taxreg">Tax registration (optional)</FieldLabel>
+              <Input id="ev-taxreg" value={taxReg} onChange={(e) => setTaxReg(e.target.value)} placeholder="134567890-7000" />
+            </Field>
+            <Field data-invalid={!!errors.currency}>
+              <FieldLabel htmlFor="ev-currency" required>Currency</FieldLabel>
+              <Input
+                id="ev-currency"
+                value={currency}
+                onChange={(e) => {
+                  setCurrency(e.target.value)
+                  clearErrors("currency")
+                }}
+                placeholder="LKR"
+                maxLength={3}
+                aria-invalid={!!errors.currency}
+              />
+              <FieldError errors={[errors.currency ? { message: errors.currency } : undefined]} />
+            </Field>
+          </FieldGroup>
+        )}
+
+        <div className="flex flex-col-reverse gap-3 pt-2 sm:flex-row sm:justify-center">
+          <Button variant="outline" className="w-full sm:w-auto sm:min-w-36" onClick={onClose} disabled={saving}>
+            Cancel
+          </Button>
+          <Button className="w-full sm:w-auto sm:min-w-36" onClick={handleSave} disabled={saving || !vendor}>
+            {saving ? "Saving…" : "Save"}
+          </Button>
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/Frontend/erp-system/hooks/use-tracking-settings.ts b/Frontend/erp-system/hooks/use-tracking-settings.ts
new file mode 100644
index 0000000..f16f46e
--- /dev/null
+++ b/Frontend/erp-system/hooks/use-tracking-settings.ts
@@ -0,0 +1,36 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+import { trackingApi } from "@/lib/api/tracking"
+import { TrackingSettings } from "@/types/tracking"
+
+// One request per page load, shared by every component that asks; the Product Configuration
+// page calls invalidateTrackingSettings() after a toggle so the next read is fresh.
+let cached: Promise<TrackingSettings> | null = null
+
+function load(): Promise<TrackingSettings> {
+  // A failed read falls back to the server's own default (serial numbers on).
+  cached ??= trackingApi.settings().catch(() => ({ serialNumbersEnabled: true }))
+  return cached
+}
+
+export function invalidateTrackingSettings() {
+  cached = null
+}
+
+/**
+ * Product Configuration tracking switches (docs/ITEM_TRACKING_PLAN.md §8). `serialNumbersEnabled`
+ * is null until loaded — callers treat that like "on", the server default.
+ */
+export function useTrackingSettings(): { serialNumbersEnabled: boolean | null } {
+  const [settings, setSettings] = useState<TrackingSettings | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    load().then((s) => { if (!cancelled) setSettings(s) })
+    return () => { cancelled = true }
+  }, [])
+
+  return { serialNumbersEnabled: settings?.serialNumbersEnabled ?? null }
+}
diff --git a/Frontend/erp-system/lib/api/approvals.ts b/Frontend/erp-system/lib/api/approvals.ts
new file mode 100644
index 0000000..a3cb4dd
--- /dev/null
+++ b/Frontend/erp-system/lib/api/approvals.ts
@@ -0,0 +1,62 @@
+// Approvals inbox and settings (docs/DUAL_APPROVAL_PLAN.md §7, §10), plus price adjustments (§6).
+import { apiRequest, buildQuery } from "@/lib/api-client"
+import { PagedResponse } from "@/types/common"
+import {
+  ApprovalConfig,
+  CreatePriceAdjustmentRequest,
+  ItemPriceHistory,
+  PendingApprovals,
+  PriceAdjustment,
+  PriceAdjustmentStatus,
+  PriceAdjustmentSummary,
+  UpdateApprovalConfigRequest,
+} from "@/types/approvals"
+
+export const approvalsApi = {
+  /** What you can approve, plus your own requests that are waiting for others. */
+  pending(): Promise<PendingApprovals> {
+    return apiRequest<PendingApprovals>("/approvals/pending")
+  },
+
+  getConfig(): Promise<ApprovalConfig> {
+    return apiRequest<ApprovalConfig>("/approvals/config")
+  },
+
+  /** Needs settings.approvals. */
+  updateConfig(request: UpdateApprovalConfigRequest): Promise<ApprovalConfig> {
+    return apiRequest<ApprovalConfig>("/approvals/config", { method: "PUT", body: request })
+  },
+}
+
+export const priceAdjustmentsApi = {
+  list(params: { page?: number; pageSize?: number; q?: string; status?: PriceAdjustmentStatus; itemId?: number } = {}): Promise<PagedResponse<PriceAdjustmentSummary>> {
+    return apiRequest<PagedResponse<PriceAdjustmentSummary>>(`/price-adjustments${buildQuery(params)}`)
+  },
+
+  get(priceAdjustmentId: number): Promise<PriceAdjustment> {
+    return apiRequest<PriceAdjustment>(`/price-adjustments/${priceAdjustmentId}`)
+  },
+
+  /** 409 PRICE_ADJUSTMENT_ITEM_PENDING when an item already has a pending request. */
+  create(request: CreatePriceAdjustmentRequest): Promise<PriceAdjustment> {
+    return apiRequest<PriceAdjustment>("/price-adjustments", { method: "POST", body: request })
+  },
+
+  /** The final approval applies the prices; 409 PRICE_ADJUSTMENT_STALE if an item was repriced meanwhile. */
+  approve(priceAdjustmentId: number, comment?: string): Promise<PriceAdjustment> {
+    return apiRequest<PriceAdjustment>(`/price-adjustments/${priceAdjustmentId}/approve`, { method: "POST", body: { comment } })
+  },
+
+  reject(priceAdjustmentId: number, reason: string): Promise<PriceAdjustment> {
+    return apiRequest<PriceAdjustment>(`/price-adjustments/${priceAdjustmentId}/reject`, { method: "POST", body: { reason } })
+  },
+
+  /** Requester only, while pending. */
+  cancel(priceAdjustmentId: number): Promise<PriceAdjustment> {
+    return apiRequest<PriceAdjustment>(`/price-adjustments/${priceAdjustmentId}/cancel`, { method: "POST" })
+  },
+
+  itemHistory(itemId: number): Promise<ItemPriceHistory[]> {
+    return apiRequest<ItemPriceHistory[]>(`/items/${itemId}/price-history`)
+  },
+}
diff --git a/Frontend/erp-system/lib/api/bank-deposits.ts b/Frontend/erp-system/lib/api/bank-deposits.ts
new file mode 100644
index 0000000..9c01ca9
--- /dev/null
+++ b/Frontend/erp-system/lib/api/bank-deposits.ts
@@ -0,0 +1,43 @@
+// Bank deposits of till cash (docs/BANK_DEPOSIT_MODULE_PLAN.md §7.3). create() posts GL (Debit bank /
+// Credit cash) and is rejected above the cash in hand; cancel() posts the reversing entry.
+import { apiRequest, buildQuery } from "@/lib/api-client"
+import {
+  BankDeposit,
+  BankDepositList,
+  BankDepositListFilterParams,
+  CashInHand,
+  CashInHandDaily,
+  CreateBankDepositRequest,
+} from "@/types/bank-deposits"
+
+export const bankDepositsApi = {
+  list(params: BankDepositListFilterParams = {}): Promise<BankDepositList> {
+    return apiRequest<BankDepositList>(`/bank-deposits${buildQuery(params)}`)
+  },
+
+  get(bankDepositId: number): Promise<BankDeposit> {
+    return apiRequest<BankDeposit>(`/bank-deposits/${bankDepositId}`)
+  },
+
+  /** 400 BANK_DEPOSIT_EXCEEDS_CASH_IN_HAND when the amount is more than can still be deposited for that day. */
+  create(request: CreateBankDepositRequest): Promise<BankDeposit> {
+    return apiRequest<BankDeposit>("/bank-deposits", { method: "POST", body: request })
+  },
+
+  /** Posted only; puts the cash back in hand. */
+  cancel(bankDepositId: number, reason: string): Promise<BankDeposit> {
+    return apiRequest<BankDeposit>(`/bank-deposits/${bankDepositId}/cancel`, { method: "POST", body: { reason } })
+  },
+
+  /** `date` omitted ⇒ today in the business time zone. `branchId` is ignored for branch users. */
+  cashInHand(params: { date?: string; branchId?: number | null } = {}): Promise<CashInHand> {
+    return apiRequest<CashInHand>(`/bank-deposits/cash-in-hand${buildQuery({ date: params.date, branchId: params.branchId ?? undefined })}`)
+  },
+
+  /** At most 92 days. */
+  cashInHandDaily(params: { from: string; to: string; branchId?: number | null }): Promise<CashInHandDaily> {
+    return apiRequest<CashInHandDaily>(
+      `/bank-deposits/cash-in-hand/daily${buildQuery({ from: params.from, to: params.to, branchId: params.branchId ?? undefined })}`
+    )
+  },
+}
diff --git a/Frontend/erp-system/lib/api/day-end-report.ts b/Frontend/erp-system/lib/api/day-end-report.ts
new file mode 100644
index 0000000..5f95e28
--- /dev/null
+++ b/Frontend/erp-system/lib/api/day-end-report.ts
@@ -0,0 +1,17 @@
+// Day-End Sales Report (docs/DAY_END_SALES_REPORT_PLAN.md §4). Read-only: one day's sales,
+// payments by method, expenses and income, and the same day-wise over a range (≤ 92 days).
+import { apiRequest, buildQuery } from "@/lib/api-client"
+import { DayEndDailyReport, DayEndReport } from "@/types/sales"
+
+export const dayEndReportApi = {
+  /** `date` omitted ⇒ today in the report's time zone. `branchId` is ignored for non-admins. */
+  getDay(params: { date?: string; branchId?: number | null } = {}): Promise<DayEndReport> {
+    return apiRequest<DayEndReport>(`/day-end-report${buildQuery({ date: params.date, branchId: params.branchId ?? undefined })}`)
+  },
+
+  getDaily(params: { from: string; to: string; branchId?: number | null }): Promise<DayEndDailyReport> {
+    return apiRequest<DayEndDailyReport>(
+      `/day-end-report/daily${buildQuery({ from: params.from, to: params.to, branchId: params.branchId ?? undefined })}`
+    )
+  },
+}
diff --git a/Frontend/erp-system/lib/api/expenses.ts b/Frontend/erp-system/lib/api/expenses.ts
new file mode 100644
index 0000000..261fec5
--- /dev/null
+++ b/Frontend/erp-system/lib/api/expenses.ts
@@ -0,0 +1,93 @@
+// One typed client method per Expense endpoint (docs/EXPENSE_MODULE_PLAN.md §6). Draft
+// expenses are editable via update(); post() accrues to GL, pay()/postAndPay() settle it.
+import { apiRequest, apiRequestWithETag, buildQuery } from "@/lib/api-client"
+import { ApiResult, PagedResponse } from "@/types/common"
+import {
+  CreateExpensePaymentRequest,
+  CreateExpenseRequest,
+  CreateExpenseTitleRequest,
+  Expense,
+  ExpenseCategory,
+  ExpenseListFilterParams,
+  ExpensePayment,
+  ExpenseSummary,
+  ExpenseSummaryReport,
+  ExpenseTitle,
+  UpdateExpenseCategoryRequest,
+  UpdateExpenseRequest,
+  UpdateExpenseTitleRequest,
+} from "@/types/expenses"
+
+export const expenseSetupApi = {
+  /** Categories with their titles, in display order. Inactive rows only when asked for. */
+  list(includeInactive = false): Promise<ExpenseCategory[]> {
+    return apiRequest<ExpenseCategory[]>(`/expense-categories${buildQuery({ includeInactive: includeInactive || undefined })}`)
+  },
+
+  /** Categories are fixed (no create); in practice only the active flag changes — they're all built-in. */
+  updateCategory(expenseCategoryId: number, request: UpdateExpenseCategoryRequest): Promise<ExpenseCategory> {
+    return apiRequest<ExpenseCategory>(`/expense-categories/${expenseCategoryId}`, { method: "PUT", body: request })
+  },
+
+  createTitle(expenseCategoryId: number, request: CreateExpenseTitleRequest): Promise<ExpenseTitle> {
+    return apiRequest<ExpenseTitle>(`/expense-categories/${expenseCategoryId}/titles`, { method: "POST", body: request })
+  },
+
+  /** 409 EXPENSE_SYSTEM_ROW_READONLY when renaming a built-in title (GL code and status stay editable). */
+  updateTitle(expenseTitleId: number, request: UpdateExpenseTitleRequest): Promise<ExpenseTitle> {
+    return apiRequest<ExpenseTitle>(`/expense-titles/${expenseTitleId}`, { method: "PUT", body: request })
+  },
+}
+
+export const expensesApi = {
+  list(params: ExpenseListFilterParams = {}): Promise<PagedResponse<ExpenseSummary>> {
+    return apiRequest<PagedResponse<ExpenseSummary>>(`/expenses${buildQuery(params)}`)
+  },
+
+  /** Posted expenses dated in [from, to] (default: this month), plus the unpaid/overdue position. */
+  summary(params: { from?: string; to?: string } = {}): Promise<ExpenseSummaryReport> {
+    return apiRequest<ExpenseSummaryReport>(`/expenses/summary${buildQuery(params)}`)
+  },
+
+  get(expenseId: number): Promise<ApiResult<Expense>> {
+    return apiRequestWithETag<Expense>(`/expenses/${expenseId}`)
+  },
+
+  create(request: CreateExpenseRequest): Promise<ApiResult<Expense>> {
+    return apiRequestWithETag<Expense>("/expenses", { method: "POST", body: request })
+  },
+
+  /** Draft only (409 EXPENSE_NOT_DRAFT otherwise). Echo the ETag from get()/create() as ifMatch. */
+  update(expenseId: number, request: UpdateExpenseRequest, ifMatch: string): Promise<ApiResult<Expense>> {
+    return apiRequestWithETag<Expense>(`/expenses/${expenseId}`, { method: "PUT", body: request, ifMatch })
+  },
+
+  /** Draft only. */
+  remove(expenseId: number): Promise<void> {
+    return apiRequest<void>(`/expenses/${expenseId}`, { method: "DELETE" })
+  },
+
+  /** Accrue to GL: Debit the title's expense account / Credit Accrued Expenses. */
+  post(expenseId: number): Promise<Expense> {
+    return apiRequest<Expense>(`/expenses/${expenseId}/post`, { method: "POST" })
+  },
+
+  /** Draft only; posts and pays in one transaction — full or partial (the rest stays as the balance). */
+  postAndPay(expenseId: number, request: CreateExpensePaymentRequest): Promise<Expense> {
+    return apiRequest<Expense>(`/expenses/${expenseId}/post-and-pay`, { method: "POST", body: request })
+  },
+
+  /** Draft, or Posted with no payments (posts a reversing GL entry). */
+  cancel(expenseId: number, reason: string): Promise<Expense> {
+    return apiRequest<Expense>(`/expenses/${expenseId}/cancel`, { method: "POST", body: { reason } })
+  },
+
+  /** Posted only; total capped at the balance. Returns one row per payment line. */
+  pay(expenseId: number, request: CreateExpensePaymentRequest): Promise<ExpensePayment[]> {
+    return apiRequest<ExpensePayment[]>(`/expenses/${expenseId}/payments`, { method: "POST", body: request })
+  },
+
+  listPayments(expenseId: number): Promise<ExpensePayment[]> {
+    return apiRequest<ExpensePayment[]>(`/expenses/${expenseId}/payments`)
+  },
+}
diff --git a/Frontend/erp-system/lib/api/items.ts b/Frontend/erp-system/lib/api/items.ts
index 5f39b1a..4cdf7ab 100644
--- a/Frontend/erp-system/lib/api/items.ts
+++ b/Frontend/erp-system/lib/api/items.ts
@@ -8,6 +8,7 @@ import {
   ItemImage,
   ItemListItem,
   ItemOverview,
+  ItemPurchasePrice,
   ItemReorderSetting,
   ItemScanResult,
   StockNature,
@@ -95,6 +96,11 @@ export const itemsApi = {
     return apiRequest<void>(`/items/${itemId}/status`, { method: "PATCH", body: { status } })
   },
 
+  /** Latest posted GRN receipts of the item (newest first) — what it was bought at. */
+  purchasePrices(itemId: number, take = 5): Promise<ItemPurchasePrice[]> {
+    return apiRequest<ItemPurchasePrice[]>(`/items/${itemId}/purchase-prices${buildQuery({ take })}`)
+  },
+
   updateReorder(itemId: number, request: UpdateItemReorderRequest): Promise<{ settings: ItemReorderSetting[] }> {
     return apiRequest<{ settings: ItemReorderSetting[] }>(`/items/${itemId}/reorder`, {
       method: "PUT",
diff --git a/Frontend/erp-system/lib/api/stock-adjustments.ts b/Frontend/erp-system/lib/api/stock-adjustments.ts
index dfe4683..ad7506a 100644
--- a/Frontend/erp-system/lib/api/stock-adjustments.ts
+++ b/Frontend/erp-system/lib/api/stock-adjustments.ts
@@ -1,8 +1,9 @@
-// One typed client method per adjustment endpoint (docs/11-BACKEND-PHASE1.md §5.5).
-// Auto-posts on create with a mandatory reason code (FR-STK-07).
+// One typed client method per adjustment endpoint (docs/11-BACKEND-PHASE1.md §5.5). Creating
+// submits a request with a mandatory reason code; it moves stock once approved
+// (docs/DUAL_APPROVAL_PLAN.md §5), or at once when approvals are switched off.
 import { apiRequest, buildQuery } from "@/lib/api-client"
 import { PagedResponse } from "@/types/common"
-import { CreateAdjustmentRequest, StockAdjustment, StockAdjustmentSummary } from "@/types/stock"
+import { AdjustmentStatus, CreateAdjustmentRequest, StockAdjustment, StockAdjustmentSummary } from "@/types/stock"
 
 export interface ListAdjustmentsParams {
   page?: number
@@ -11,6 +12,7 @@ export interface ListAdjustmentsParams {
   warehouseId?: number
   branchId?: number
   reasonCodeId?: number
+  status?: AdjustmentStatus
   sort?: string
 }
 
@@ -30,4 +32,18 @@ export const stockAdjustmentsApi = {
   create(request: CreateAdjustmentRequest): Promise<StockAdjustment> {
     return apiRequest<StockAdjustment>("/stock-adjustments", { method: "POST", body: request })
   },
+
+  /** Next approval; the final one posts (409 STOCK_NEGATIVE_BLOCKED if stock no longer allows it). */
+  approve(adjustmentId: number, comment?: string): Promise<StockAdjustment> {
+    return apiRequest<StockAdjustment>(`/stock-adjustments/${adjustmentId}/approve`, { method: "POST", body: { comment } })
+  },
+
+  reject(adjustmentId: number, reason: string): Promise<StockAdjustment> {
+    return apiRequest<StockAdjustment>(`/stock-adjustments/${adjustmentId}/reject`, { method: "POST", body: { reason } })
+  },
+
+  /** Requester only, while pending. */
+  cancel(adjustmentId: number): Promise<StockAdjustment> {
+    return apiRequest<StockAdjustment>(`/stock-adjustments/${adjustmentId}/cancel`, { method: "POST" })
+  },
 }
diff --git a/Frontend/erp-system/lib/api/tracking.ts b/Frontend/erp-system/lib/api/tracking.ts
new file mode 100644
index 0000000..2d111e6
--- /dev/null
+++ b/Frontend/erp-system/lib/api/tracking.ts
@@ -0,0 +1,89 @@
+// Item tracking endpoints — pickers (/tracking), serial register (/serials), warranty register
+// (/warranties) and batch stock (/stock/batches). docs/ITEM_TRACKING_PLAN.md.
+import { apiRequest, buildQuery } from "@/lib/api-client"
+import { PagedResponse } from "@/types/common"
+import {
+  AvailableBatch,
+  AvailableSerial,
+  BatchStock,
+  BatchSuggestion,
+  SerialDetail,
+  SerialStatus,
+  SerialSummary,
+  TrackingSettings,
+  WarrantyRegistration,
+  WarrantyStatus,
+} from "@/types/tracking"
+
+export interface SerialListParams {
+  q?: string
+  itemId?: number
+  warehouseId?: number
+  status?: SerialStatus
+  page?: number
+  pageSize?: number
+}
+
+export interface WarrantyListParams {
+  q?: string
+  customerId?: number
+  itemId?: number
+  serialNo?: string
+  status?: WarrantyStatus
+  expiringWithinDays?: number
+  expired?: boolean
+  page?: number
+  pageSize?: number
+}
+
+export interface BatchStockParams {
+  q?: string
+  itemId?: number
+  warehouseId?: number
+  expiringWithinDays?: number
+  page?: number
+  pageSize?: number
+}
+
+export const trackingApi = {
+  settings() {
+    return apiRequest<TrackingSettings>("/tracking/settings")
+  },
+
+  /** Next free serial numbers for an item under a prefix (auto-generate on GRN). */
+  nextSerialNumbers(itemId: number, prefix: string, count: number) {
+    return apiRequest<string[]>(`/tracking/serials/next-numbers${buildQuery({ itemId, prefix, count })}`)
+  },
+
+  availableSerials(itemId: number, warehouseId: number, q?: string) {
+    return apiRequest<AvailableSerial[]>(`/tracking/serials/available${buildQuery({ itemId, warehouseId, q })}`)
+  },
+
+  availableBatches(itemId: number, warehouseId: number) {
+    return apiRequest<AvailableBatch[]>(`/tracking/batches/available${buildQuery({ itemId, warehouseId })}`)
+  },
+
+  suggestBatches(itemId: number, warehouseId: number, qty: number) {
+    return apiRequest<BatchSuggestion[]>(`/tracking/batches/suggest${buildQuery({ itemId, warehouseId, qty })}`)
+  },
+
+  listSerials(params: SerialListParams = {}) {
+    return apiRequest<PagedResponse<SerialSummary>>(`/serials${buildQuery(params)}`)
+  },
+
+  getSerial(serialId: number) {
+    return apiRequest<SerialDetail>(`/serials/${serialId}`)
+  },
+
+  lookupSerial(serialNo: string) {
+    return apiRequest<SerialDetail[]>(`/serials/lookup${buildQuery({ serialNo })}`)
+  },
+
+  listWarranties(params: WarrantyListParams = {}) {
+    return apiRequest<PagedResponse<WarrantyRegistration>>(`/warranties${buildQuery(params)}`)
+  },
+
+  listBatchStock(params: BatchStockParams = {}) {
+    return apiRequest<PagedResponse<BatchStock>>(`/stock/batches${buildQuery(params)}`)
+  },
+}
diff --git a/Frontend/erp-system/lib/api/vendors.ts b/Frontend/erp-system/lib/api/vendors.ts
index ab6961b..f83e303 100644
--- a/Frontend/erp-system/lib/api/vendors.ts
+++ b/Frontend/erp-system/lib/api/vendors.ts
@@ -1,6 +1,6 @@
 // One typed client method per vendor (supplier) endpoint (docs/11-BACKEND-PHASE1.md
-// §2.4, FR-MD-06). ETag/If-Match on update, PATCH status for deactivate (masters are
-// deactivated, not hard-deleted, FR-MD-08).
+// §2.4, FR-MD-06). ETag/If-Match on update, PATCH status for deactivate, DELETE for a
+// hard delete (409 MASTER_IN_USE while any purchase document or item references it).
 import { apiRequest, apiRequestWithETag, buildQuery } from "@/lib/api-client"
 import { ApiResult, EntityStatus, PagedResponse } from "@/types/common"
 import { CreateVendorRequest, UpdateVendorRequest, Vendor } from "@/types/master-data"
@@ -33,4 +33,8 @@ export const vendorsApi = {
   updateStatus(vendorId: number, status: EntityStatus): Promise<void> {
     return apiRequest<void>(`/vendors/${vendorId}/status`, { method: "PATCH", body: { status } })
   },
+
+  delete(vendorId: number): Promise<void> {
+    return apiRequest<void>(`/vendors/${vendorId}`, { method: "DELETE" })
+  },
 }
diff --git a/Frontend/erp-system/lib/api/wastage.ts b/Frontend/erp-system/lib/api/wastage.ts
index 360c74d..db4b399 100644
--- a/Frontend/erp-system/lib/api/wastage.ts
+++ b/Frontend/erp-system/lib/api/wastage.ts
@@ -7,7 +7,7 @@
 import { reasonCodesApi } from "@/lib/api/reason-codes"
 import { stockAdjustmentsApi } from "@/lib/api/stock-adjustments"
 import { stockApi } from "@/lib/api/stock"
-import { StockAdjustment } from "@/types/stock"
+import { AdjustmentStatus, StockAdjustment } from "@/types/stock"
 
 /**
  * Reason codes treated as "wastage" (loss-type) causes. These match the seeded codes in
@@ -37,8 +37,10 @@ export interface WastageRecord {
   reasonCodeId: number
   /** Positive quantity wasted (the underlying adjustment line is a negative qtyDelta). */
   qty: number
-  /** FIFO cost of the wasted quantity, summed from the ledger entries this adjustment posted. */
+  /** FIFO cost of the wasted quantity, summed from the ledger entries this adjustment posted (0 until posted). */
   value: number
+  /** Posted, or still waiting for approval (rejected/withdrawn requests are left out). */
+  status: AdjustmentStatus
 }
 
 export interface ListWastageParams {
@@ -81,7 +83,8 @@ export const wastageApi = {
       page: params.page,
       pageSize: params.pageSize ?? 50,
     })
-    const summaries = res.items.filter((a) => wastageIds.has(a.reasonCodeId))
+    // A rejected or withdrawn request never wrote anything off.
+    const summaries = res.items.filter((a) => wastageIds.has(a.reasonCodeId) && a.status !== "Rejected" && a.status !== "Cancelled")
 
     const detailed = await Promise.all(
       summaries.map(async (summary) => {
@@ -107,6 +110,7 @@ export const wastageApi = {
               reasonCodeId: adjustment.reasonCodeId,
               qty: Math.abs(line.qtyDelta),
               value: Math.round(value * 100) / 100,
+              status: adjustment.status,
             }
           })
       }),
diff --git a/Frontend/erp-system/lib/format.ts b/Frontend/erp-system/lib/format.ts
index 28e9275..61d75d6 100644
--- a/Frontend/erp-system/lib/format.ts
+++ b/Frontend/erp-system/lib/format.ts
@@ -15,6 +15,18 @@ export function formatAmount(value: number | null | undefined, zeroDash = false)
   return value < 0 ? `(${formatted})` : formatted
 }
 
+/** Like {@link formatAmount} but a negative keeps a leading minus instead of parentheses: `-1234.5` -> "-1,234.50". */
+export function formatSignedAmount(value: number | null | undefined): string {
+  if (value === null || value === undefined || Number.isNaN(value)) return "—"
+  return value < 0 ? `-${AMOUNT_FORMATTER.format(Math.abs(value))}` : AMOUNT_FORMATTER.format(value)
+}
+
+/** A profit figure as words + amount: `1200` -> { label: "Profit", amount: "1,200.00" }, `-300` -> { label: "Loss", amount: "300.00" }. */
+export function profitOrLoss(value: number): { label: "Profit" | "Loss"; amount: string; isLoss: boolean } {
+  const isLoss = value < 0
+  return { label: isLoss ? "Loss" : "Profit", amount: formatAmount(Math.abs(value)), isLoss }
+}
+
 /** `"2026-07-01"` / an ISO timestamp -> "01 Jul 2026" for report headers and tables. */
 export function formatReportDate(value: string | null | undefined): string {
   if (!value) return "—"
diff --git a/Frontend/erp-system/lib/pdf/day-end-report-pdf.ts b/Frontend/erp-system/lib/pdf/day-end-report-pdf.ts
new file mode 100644
index 0000000..48e2cf3
--- /dev/null
+++ b/Frontend/erp-system/lib/pdf/day-end-report-pdf.ts
@@ -0,0 +1,428 @@
+// Day-End Sales Report PDFs (docs/DAY_END_SALES_REPORT_PLAN.md §6) — built in the browser with
+// jsPDF (the backend has no PDF library). The table is drawn directly rather than through
+// jspdf-autotable, so no extra dependency; the chart is rendered on an offscreen canvas in light
+// colours, so the printout never depends on the on-screen theme.
+import type { jsPDF as JsPdf } from "jspdf"
+
+import { formatAmount, formatReportDate, formatSignedAmount, profitOrLoss } from "@/lib/format"
+import { maskAccountNumber } from "@/types/bank-deposits"
+import { DayEndDailyReport, DayEndReport, DayEndReportDay } from "@/types/sales"
+
+const PAGE = { width: 210, height: 297, margin: 14 }
+const BOTTOM = PAGE.height - 16
+
+type Column = { header: string; width: number; align?: "left" | "right" }
+
+async function newDoc(): Promise<JsPdf> {
+  const { jsPDF } = await import("jspdf")
+  return new jsPDF({ unit: "mm", format: "a4" })
+}
+
+/** Title block; returns the y where content starts. */
+function header(doc: JsPdf, title: string, subtitle: string, branchLabel: string): number {
+  doc.setFont("helvetica", "bold")
+  doc.setFontSize(16)
+  doc.text(title, PAGE.margin, 20)
+  doc.setFont("helvetica", "normal")
+  doc.setFontSize(10)
+  doc.setTextColor(90)
+  doc.text(subtitle, PAGE.margin, 27)
+  doc.text(`Branch: ${branchLabel}`, PAGE.margin, 32)
+  doc.text(`Generated ${new Date().toLocaleString()}`, PAGE.width - PAGE.margin, 32, { align: "right" })
+  doc.setTextColor(0)
+  doc.setDrawColor(200)
+  doc.line(PAGE.margin, 35, PAGE.width - PAGE.margin, 35)
+  return 42
+}
+
+function footer(doc: JsPdf) {
+  const pages = doc.getNumberOfPages()
+  for (let i = 1; i <= pages; i++) {
+    doc.setPage(i)
+    doc.setFontSize(8)
+    doc.setTextColor(120)
+    doc.text(`Page ${i} of ${pages}`, PAGE.width - PAGE.margin, PAGE.height - 8, { align: "right" })
+    doc.setTextColor(0)
+  }
+}
+
+/** Label/value pairs in a grid of boxes. */
+function summaryGrid(doc: JsPdf, y: number, items: [string, string][], perRow = 4): number {
+  const gap = 3
+  const w = (PAGE.width - PAGE.margin * 2 - gap * (perRow - 1)) / perRow
+  const h = 14
+  items.forEach(([label, value], i) => {
+    const x = PAGE.margin + (i % perRow) * (w + gap)
+    const top = y + Math.floor(i / perRow) * (h + gap)
+    doc.setDrawColor(215)
+    doc.roundedRect(x, top, w, h, 1.5, 1.5)
+    doc.setFontSize(8)
+    doc.setTextColor(100)
+    doc.text(label, x + 2.5, top + 5)
+    doc.setFontSize(11)
+    doc.setTextColor(0)
+    doc.setFont("helvetica", "bold")
+    doc.text(value, x + 2.5, top + 11)
+    doc.setFont("helvetica", "normal")
+  })
+  return y + Math.ceil(items.length / perRow) * (h + gap) + 2
+}
+
+function note(doc: JsPdf, y: number, text: string): number {
+  doc.setFontSize(9)
+  doc.setTextColor(110)
+  doc.text(text, PAGE.margin, y + 4)
+  doc.setTextColor(0)
+  return y + 8
+}
+
+function sectionTitle(doc: JsPdf, y: number, text: string): number {
+  doc.setFont("helvetica", "bold")
+  doc.setFontSize(11)
+  doc.text(text, PAGE.margin, y)
+  doc.setFont("helvetica", "normal")
+  return y + 4
+}
+
+/** Cut `text` with "..." so it fits `maxWidth` mm at the current font. */
+function fit(doc: JsPdf, text: string, maxWidth: number): string {
+  if (doc.getTextWidth(text) <= maxWidth) return text
+  let cut = text
+  while (cut.length > 1 && doc.getTextWidth(`${cut}...`) > maxWidth) cut = cut.slice(0, -1)
+  return `${cut}...`
+}
+
+/** A table that breaks across pages, repeating its header; `totals` is a bold last row. */
+function table(doc: JsPdf, y: number, columns: Column[], rows: string[][], totals?: string[]): number {
+  const rowH = 6.5
+  const drawHeader = (top: number) => {
+    doc.setFillColor(238, 238, 236)
+    doc.rect(PAGE.margin, top, PAGE.width - PAGE.margin * 2, rowH, "F")
+    doc.setFont("helvetica", "bold")
+    drawRow(top, columns.map((c) => c.header))
+    doc.setFont("helvetica", "normal")
+    return top + rowH
+  }
+  const drawRow = (top: number, cells: string[]) => {
+    doc.setFontSize(8.5)
+    let x = PAGE.margin
+    columns.forEach((col, i) => {
+      const text = fit(doc, cells[i] ?? "", col.width - 4)
+      if (col.align === "right") doc.text(text, x + col.width - 2, top + 4.5, { align: "right" })
+      else doc.text(text, x + 2, top + 4.5)
+      x += col.width
+    })
+  }
+
+  let top = drawHeader(y)
+  const all = totals ? [...rows, totals] : rows
+  all.forEach((cells, idx) => {
+    if (top + rowH > BOTTOM) {
+      doc.addPage()
+      top = drawHeader(20)
+    }
+    const isTotals = totals !== undefined && idx === all.length - 1
+    if (isTotals) {
+      doc.setDrawColor(150)
+      doc.line(PAGE.margin, top, PAGE.width - PAGE.margin, top)
+      doc.setFont("helvetica", "bold")
+    } else if (idx % 2 === 1) {
+      doc.setFillColor(248, 248, 246)
+      doc.rect(PAGE.margin, top, PAGE.width - PAGE.margin * 2, rowH, "F")
+    }
+    drawRow(top, cells)
+    doc.setFont("helvetica", "normal")
+    top += rowH
+  })
+  return top + 4
+}
+
+/** The income/sales/expenses line chart as a PNG, drawn offscreen in the light palette. */
+async function chartImage(days: DayEndReportDay[]): Promise<string> {
+  const { Chart, CategoryScale, LinearScale, PointElement, LineElement, Legend } = await import("chart.js")
+  Chart.register(CategoryScale, LinearScale, PointElement, LineElement, Legend)
+
+  const canvas = document.createElement("canvas")
+  canvas.width = 1600
+  canvas.height = 640
+  const series = (label: string, data: number[], color: string) => ({
+    label, data, borderColor: color, backgroundColor: color, borderWidth: 3,
+    pointRadius: days.length > 45 ? 0 : 4, tension: 0.25, fill: false,
+  })
+  const chart = new Chart(canvas, {
+    type: "line",
+    data: {
+      labels: days.map((d) => formatReportDate(d.date)),
+      datasets: [
+        series("Income", days.map((d) => d.income), "#2a78d6"),
+        series("Sales", days.map((d) => d.totalSales), "#eb6834"),
+        series("Expenses", days.map((d) => d.expenseTotal), "#1baf7a"),
+        series("Profit / loss", days.map((d) => d.netProfit), "#eda100"),
+      ],
+    },
+    options: {
+      responsive: false,
+      animation: false,
+      devicePixelRatio: 1,
+      plugins: { legend: { position: "top", align: "start", labels: { font: { size: 22 }, usePointStyle: true } } },
+      scales: {
+        x: { grid: { display: false }, ticks: { font: { size: 18 }, maxRotation: 0, autoSkip: true, maxTicksLimit: 10 } },
+        y: { grid: { color: "rgba(0,0,0,0.08)" }, ticks: { font: { size: 18 }, callback: (v) => formatAmount(Number(v)) } },
+      },
+    },
+  })
+  const png = chart.toBase64Image("image/png", 1)
+  chart.destroy()
+  return png
+}
+
+const amount = (n: number) => formatAmount(n)
+
+/** Income with a minus sign when negative, marked as a loss: "Loss -300.00". */
+const incomeText = (n: number) => (n < 0 ? `Loss ${formatSignedAmount(n)}` : formatSignedAmount(n))
+
+/** "Profit 1,200.00" / "Loss 300.00" — a loss is labelled, not just negative. */
+const profitText = (n: number) => {
+  const p = profitOrLoss(n)
+  return `${p.label} ${p.amount}`
+}
+
+function totalsGrid(t: DayEndReportDay): [string, string][] {
+  const net = profitOrLoss(t.netProfit)
+  return [
+    ["Total sales", amount(t.totalSales)],
+    ["Paid", amount(t.paidAmount)],
+    ["Due", amount(t.dueAmount)],
+    ["Expenses", amount(t.expenseTotal)],
+    ["Paid by cash", amount(t.paidByCash)],
+    ["Paid by card", amount(t.paidByCard)],
+    [t.income < 0 ? "Income (loss)" : "Income", formatSignedAmount(t.income)],
+    [`Net ${net.label.toLowerCase()}`, net.amount],
+  ]
+}
+
+const DAILY_COLUMNS: Column[] = [
+  { header: "Date", width: 21 },
+  { header: "Sales", width: 20, align: "right" },
+  { header: "Paid", width: 19, align: "right" },
+  { header: "Due", width: 17, align: "right" },
+  { header: "Cash", width: 18, align: "right" },
+  { header: "Card", width: 18, align: "right" },
+  { header: "Expenses", width: 19, align: "right" },
+  { header: "Income", width: 20, align: "right" },
+  { header: "Profit / loss", width: 30, align: "right" },
+]
+
+const dailyCells = (d: DayEndReportDay, label: string) => [
+  label, amount(d.totalSales), amount(d.paidAmount), amount(d.dueAmount),
+  amount(d.paidByCash), amount(d.paidByCard), amount(d.expenseTotal), incomeText(d.income), profitText(d.netProfit),
+]
+
+const CASH_COLUMNS: Column[] = [
+  { header: "Date", width: 30 },
+  { header: "Opening cash", width: 38, align: "right" },
+  { header: "Net cash", width: 38, align: "right" },
+  { header: "Deposited to bank", width: 38, align: "right" },
+  { header: "Cash in hand", width: 38, align: "right" },
+]
+
+const cashCells = (d: DayEndReportDay, label: string) => [
+  label, amount(d.openingCashInHand ?? 0), amount(d.netCash), amount(d.cashDeposited ?? 0), amount(d.closingCashInHand ?? 0),
+]
+
+/** Sales − cost = gross, − expenses = net profit/loss, as a right-aligned statement. */
+function profitStatement(doc: JsPdf, y: number, s: DayEndReportDay): number {
+  const gross = profitOrLoss(s.grossProfit)
+  const net = profitOrLoss(s.netProfit)
+  const left = PAGE.width - PAGE.margin - 95
+  const right = PAGE.width - PAGE.margin
+  const rows: [string, string][] = [
+    ["Total sales", amount(s.totalSales)],
+    ["Less: cost of goods sold", `(${amount(s.costOfGoodsSold)})`],
+    [`Gross ${gross.label.toLowerCase()}`, gross.amount],
+    ["Less: expenses", `(${amount(s.expenseTotal)})`],
+  ]
+  doc.setFontSize(10)
+  rows.forEach(([label, value]) => {
+    doc.text(label, left, y)
+    doc.text(value, right, y, { align: "right" })
+    y += 6
+  })
+  doc.setDrawColor(150)
+  doc.line(left, y - 3.5, right, y - 3.5)
+  doc.setFont("helvetica", "bold")
+  doc.setFontSize(12)
+  if (net.isLoss) doc.setTextColor(200, 40, 40)
+  else doc.setTextColor(0, 120, 0)
+  doc.text(`Net ${net.label.toLowerCase()}`, left, y + 2)
+  doc.text(net.amount, right, y + 2, { align: "right" })
+  doc.setTextColor(0)
+  doc.setFont("helvetica", "normal")
+  return y + 10
+}
+
+/** Day-wise income for a range: totals, the chart, then the daily table (with a totals row). */
+export async function downloadDailyIncomePdf(report: DayEndDailyReport, branchLabel: string) {
+  const doc = await newDoc()
+  let y = header(
+    doc,
+    "Day-wise Income Report",
+    `${formatReportDate(report.from)} to ${formatReportDate(report.to)} (${report.days.length} days)`,
+    branchLabel
+  )
+  y = summaryGrid(doc, y, totalsGrid(report.totals))
+
+  y = sectionTitle(doc, y + 2, "Daily income")
+  const chartW = PAGE.width - PAGE.margin * 2
+  const chartH = chartW * (640 / 1600)
+  doc.addImage(await chartImage(report.days), "PNG", PAGE.margin, y, chartW, chartH)
+  y += chartH + 6
+
+  if (y + 20 > BOTTOM) {
+    doc.addPage()
+    y = 20
+  }
+  y = sectionTitle(doc, y, "Day-wise breakdown")
+  y = table(
+    doc,
+    y,
+    DAILY_COLUMNS,
+    report.days.map((d) => dailyCells(d, formatReportDate(d.date))),
+    dailyCells(report.totals, "Total")
+  )
+
+  // Its own table: the breakdown above already fills the page width.
+  if (y + 20 > BOTTOM) {
+    doc.addPage()
+    y = 20
+  }
+  y = sectionTitle(doc, y + 2, "Cash in hand and bank deposits")
+  const t = report.totals
+  table(
+    doc,
+    y,
+    CASH_COLUMNS,
+    report.days.map((d) => cashCells(d, formatReportDate(d.date))),
+    // Opening and closing are balances: the range opens with its first day and closes with its last.
+    ["Total", amount(t.openingCashInHand ?? 0), amount(t.netCash), amount(t.cashDeposited ?? 0), amount(t.closingCashInHand ?? 0)]
+  )
+
+  footer(doc)
+  doc.save(`daily-income_${report.from}_${report.to}.pdf`)
+}
+
+/** One business day: its figures, sale counts by payment method, the sales and expense lists, then profit/loss. */
+export async function downloadDayEndReportPdf(report: DayEndReport, branchLabel: string) {
+  const s = report.summary
+  const sales = report.sales ?? []
+  const expenses = report.expenses ?? []
+  const deposits = report.deposits ?? []
+  const doc = await newDoc()
+  let y = header(doc, "Day-End Sales Report", formatReportDate(s.date), branchLabel)
+
+  y = sectionTitle(doc, y, "Sales")
+  y = summaryGrid(doc, y + 1, [
+    ["Total sales", amount(s.totalSales)],
+    ["Paid amount", amount(s.paidAmount)],
+    ["Due amount", amount(s.dueAmount)],
+    ["Paid by cash", amount(s.paidByCash)],
+    ["Paid by card", amount(s.paidByCard)],
+    ["Paid other ways", amount(s.paidByOther)],
+    ["Earlier invoices collected", amount(s.earlierInvoiceCollections)],
+  ])
+
+  y = sectionTitle(doc, y + 2, "Cash in hand")
+  y = summaryGrid(doc, y + 1, [
+    ["Opening cash in hand", amount(s.openingCashInHand ?? 0)],
+    ["Net cash today", amount(s.netCash)],
+    ["Deposited to bank", amount(s.cashDeposited ?? 0)],
+    ["Remaining cash in hand", amount(s.closingCashInHand ?? 0)],
+  ])
+  if (deposits.length > 0) {
+    y = table(
+      doc,
+      y,
+      [
+        { header: "Deposit", width: 32 },
+        { header: "Bank account", width: 62 },
+        { header: "Slip no.", width: 30 },
+        { header: "Deposited on", width: 28 },
+        { header: "Amount", width: 30, align: "right" },
+      ],
+      deposits.map((d) => [
+        d.docNo,
+        [d.bankAccountName, d.bankName, maskAccountNumber(d.accountNumber)].filter(Boolean).join(" · "),
+        d.depositSlipNo ?? "-",
+        formatReportDate(d.depositDate),
+        amount(d.amount),
+      ]),
+      ["Total", "", "", "", amount(s.cashDeposited ?? 0)]
+    )
+  }
+
+  y = sectionTitle(doc, y + 2, "Sales count")
+  y = summaryGrid(doc, y + 1, [
+    ["All sales", String(s.salesCount)],
+    ["Cash sales", String(s.cashSalesCount)],
+    ["Card sales", String(s.cardSalesCount)],
+    ["Mixed / other / unpaid", `${s.mixedSalesCount} / ${s.otherSalesCount} / ${s.unpaidSalesCount}`],
+  ])
+
+  y = sectionTitle(doc, y + 2, `Sales of the day (${sales.length})`)
+  if (sales.length === 0) {
+    y = note(doc, y, "No posted sales on this day.")
+  } else {
+    y = table(
+      doc,
+      y,
+      [
+        { header: "Time", width: 13 },
+        { header: "No.", width: 28 },
+        { header: "Customer", width: 37 },
+        { header: "Paid by", width: 20 },
+        { header: "Total", width: 22, align: "right" },
+        { header: "Due", width: 20, align: "right" },
+        { header: "Cost", width: 20, align: "right" },
+        { header: "Profit", width: 22, align: "right" },
+      ],
+      sales.map((r) => [
+        new Date(r.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }),
+        r.docNo, r.customerName, r.paidBy, amount(r.total), amount(r.due), amount(r.cost), amount(r.grossProfit),
+      ]),
+      ["", "Total", "", "", amount(s.totalSales), amount(s.dueAmount), amount(s.costOfGoodsSold), amount(s.grossProfit)]
+    )
+  }
+
+  if (y + 20 > BOTTOM) {
+    doc.addPage()
+    y = 20
+  }
+  y = sectionTitle(doc, y + 2, `Expenses of the day (${expenses.length})`)
+  if (expenses.length === 0) {
+    y = note(doc, y, "No posted expenses on this day.")
+  } else {
+    y = table(
+      doc,
+      y,
+      [
+        { header: "Doc no.", width: 34 },
+        { header: "Category", width: 30 },
+        { header: "Title", width: 40 },
+        { header: "Payee", width: 46 },
+        { header: "Amount", width: 32, align: "right" },
+      ],
+      expenses.map((e) => [e.docNo, e.categoryName, e.titleName, e.payee ?? "-", amount(e.amount)]),
+      ["Total", "", "", "", amount(s.expenseTotal)]
+    )
+  }
+
+  if (y + 44 > BOTTOM) {
+    doc.addPage()
+    y = 20
+  }
+  y = sectionTitle(doc, y + 2, "Profit / loss")
+  profitStatement(doc, y + 4, s)
+
+  footer(doc)
+  doc.save(`day-end-report_${s.date}.pdf`)
+}
diff --git a/Frontend/erp-system/lib/tracking-tags.ts b/Frontend/erp-system/lib/tracking-tags.ts
new file mode 100644
index 0000000..19e1a5d
--- /dev/null
+++ b/Frontend/erp-system/lib/tracking-tags.ts
@@ -0,0 +1,15 @@
+import type { SuggestTagTone } from "@/components/ui/suggest-input"
+import type { TrackingMode } from "@/types/master-data"
+
+/**
+ * Highlighted tracking tag for an item in a dropdown: "Serial" or "Batch". A Serial item gets no
+ * tag while serial numbers are switched off in Product Configuration — it is plain stock then.
+ */
+export function trackingTags(
+  trackingMode: TrackingMode,
+  serialNumbersEnabled: boolean | null,
+): { label: string; tone: SuggestTagTone }[] {
+  if (trackingMode === "Serial" && serialNumbersEnabled !== false) return [{ label: "Serial", tone: "serial" }]
+  if (trackingMode === "Batch") return [{ label: "Batch", tone: "batch" }]
+  return []
+}
diff --git a/Frontend/erp-system/lib/validations/grn.ts b/Frontend/erp-system/lib/validations/grn.ts
index 8574ce9..fffe5a9 100644
--- a/Frontend/erp-system/lib/validations/grn.ts
+++ b/Frontend/erp-system/lib/validations/grn.ts
@@ -3,7 +3,7 @@
 // (over-receipt tolerance, referential existence, concurrency) are never
 // re-implemented here; the server's ProblemDetails is the final word (§3.3).
 import { z } from "zod"
-import { Warranty } from "@/types/master-data"
+import { TrackingMode, Warranty } from "@/types/master-data"
 
 export const grnHeaderSchema = z.object({
   warehouseId: z.number({ error: "Select a warehouse" }).positive("Select a warehouse"),
@@ -18,6 +18,9 @@ export function validateLine(input: {
   discountPct: string
   vatPct: string
   warranty: Warranty | null
+  trackingMode: TrackingMode | null
+  batchNo: string
+  /** Per-unit numbers: serial numbers for a Serial item, else warranty numbers for a Warranty item. */
   warrantyNumbers: string[]
 }): Record<string, string> {
   const errors: Record<string, string> = {}
@@ -38,14 +41,20 @@ export function validateLine(input: {
   if (input.vatPct !== "" && (Number.isNaN(vatPct) || vatPct < 0 || vatPct > 100))
     errors.vatPct = "VAT must be 0–100%"
 
-  if (input.warranty === "Warranty") {
+  if (input.trackingMode === "Batch" && !input.batchNo.trim()) errors.batchNo = "Enter the batch number"
+
+  const serial = input.trackingMode === "Serial"
+  if (serial && !Number.isNaN(qty) && !Number.isInteger(qty)) errors.qty = "Serial-tracked items are received in whole units"
+
+  if (serial || input.warranty === "Warranty") {
+    const label = serial ? "serial number" : "warranty number"
     const numbers = input.warrantyNumbers.map((s) => s.trim()).filter((s) => s.length > 0)
     if (numbers.length === 0) {
-      errors.warrantyNumbers = "Enter one warranty number per unit"
+      errors.warrantyNumbers = `Enter one ${label} per unit`
     } else if (!Number.isNaN(qty) && numbers.length !== qty) {
-      errors.warrantyNumbers = `Enter exactly ${qty || 0} warranty number(s) — got ${numbers.length}`
+      errors.warrantyNumbers = `Enter exactly ${qty || 0} ${label}(s) — got ${numbers.length}`
     } else if (new Set(numbers.map((s) => s.toLowerCase())).size !== numbers.length) {
-      errors.warrantyNumbers = "Warranty numbers must be unique"
+      errors.warrantyNumbers = `${serial ? "Serial" : "Warranty"} numbers must be unique`
     }
   }
 
diff --git a/Frontend/erp-system/types/approvals.ts b/Frontend/erp-system/types/approvals.ts
new file mode 100644
index 0000000..7a4328a
--- /dev/null
+++ b/Frontend/erp-system/types/approvals.ts
@@ -0,0 +1,148 @@
+// Dual approval of stock and price adjustments (docs/DUAL_APPROVAL_PLAN.md).
+// Mirrors Backend/ERPCore/Dtos/Approvals/ApprovalDtos.cs and Dtos/Products/PriceAdjustmentDtos.cs.
+
+export type ApprovalDecision = "Approved" | "Rejected"
+
+/** One decision in a document's approval trail. */
+export interface ApprovalStep {
+  level: number
+  decision: ApprovalDecision
+  decidedBy: number
+  decidedByName: string | null
+  decidedAt: string
+  comment: string | null
+}
+
+/** "ADJ" = stock adjustment, "PADJ" = price adjustment. */
+export type ApprovalDocType = "ADJ" | "PADJ"
+
+export interface PendingApproval {
+  docType: ApprovalDocType
+  docId: number
+  docNo: string
+  summary: string
+  /** The approval it waits for: 1, or 2 after the first. */
+  level: number
+  requiredApprovals: number
+  requestedBy: number
+  requestedByName: string | null
+  requestedAt: string
+  /** Whether you may give that approval; `whyNot` says why not (e.g. it's your own request). */
+  canApprove: boolean
+  whyNot: string | null
+}
+
+export interface PendingApprovals {
+  items: PendingApproval[]
+  /** How many you can act on — the sidebar badge. */
+  actionableCount: number
+}
+
+/** Settings → Approvals. Levels: 0 = applies on create, 1 = one approver, 2 = two different approvers. */
+export interface ApprovalConfig {
+  stockAdjustmentLevels: number
+  /** With 2 levels: adjustments worth less than this need one approval. 0 = always two. */
+  stockAdjustmentLevel2ThresholdValue: number
+  priceAdjustmentLevels: number
+  /** With 2 levels: price changes smaller than this % need one approval. 0 = always two. */
+  priceAdjustmentLevel2ThresholdPercent: number
+  /** Only these roles may give the second approval; empty = anyone with the Approve action. */
+  level2RoleCodes: string[]
+  updatedAt: string | null
+}
+
+export type UpdateApprovalConfigRequest = Omit<ApprovalConfig, "updatedAt">
+
+// --- Price adjustments ---------------------------------------------------------------------------
+
+export type PriceAdjustmentStatus = "PendingApproval" | "PendingSecondApproval" | "Approved" | "Rejected" | "Cancelled"
+
+/** One item's requested change. current* differ from old* when the item was repriced since (the request is then stale). */
+export interface PriceAdjustmentLine {
+  priceAdjustmentLineId: number
+  itemId: number
+  sku: string
+  itemName: string
+  oldMinPrice: number | null
+  oldMaxPrice: number | null
+  oldFlatPrice: number | null
+  newMinPrice: number | null
+  newMaxPrice: number | null
+  newFlatPrice: number | null
+  currentMinPrice: number | null
+  currentMaxPrice: number | null
+  currentFlatPrice: number | null
+}
+
+export interface PriceAdjustmentSummary {
+  priceAdjustmentId: number
+  docNo: string
+  reason: string
+  status: PriceAdjustmentStatus
+  requiredApprovals: number
+  pendingLevel: number | null
+  lineCount: number
+  createdBy: number
+  createdByName: string | null
+  createdAt: string
+  appliedAt: string | null
+}
+
+export interface PriceAdjustment {
+  priceAdjustmentId: number
+  docNo: string
+  reason: string
+  status: PriceAdjustmentStatus
+  requiredApprovals: number
+  pendingLevel: number | null
+  createdBy: number
+  createdByName: string | null
+  createdAt: string
+  approvedLevel1By: number | null
+  approvedLevel1At: string | null
+  approvedLevel2By: number | null
+  approvedLevel2At: string | null
+  rejectedBy: number | null
+  rejectedAt: string | null
+  rejectReason: string | null
+  cancelledAt: string | null
+  appliedAt: string | null
+  lines: PriceAdjustmentLine[]
+  approvalHistory: ApprovalStep[]
+  canApprove: boolean
+  whyNot: string | null
+  canWithdraw: boolean
+}
+
+export interface PriceAdjustmentLineInput {
+  itemId: number
+  /** The prices the item should have afterwards — null clears that price. */
+  newMinPrice: number | null
+  newMaxPrice: number | null
+  newFlatPrice: number | null
+}
+
+export interface CreatePriceAdjustmentRequest {
+  reason: string
+  lines: PriceAdjustmentLineInput[]
+}
+
+export interface ItemPriceHistory {
+  itemPriceHistoryId: number
+  itemId: number
+  priceAdjustmentId: number | null
+  docNo: string | null
+  oldMinPrice: number | null
+  oldMaxPrice: number | null
+  oldFlatPrice: number | null
+  newMinPrice: number | null
+  newMaxPrice: number | null
+  newFlatPrice: number | null
+  requestedBy: number
+  requestedByName: string | null
+  approvedLevel1By: number | null
+  approvedLevel1ByName: string | null
+  approvedLevel2By: number | null
+  approvedLevel2ByName: string | null
+  appliedAt: string
+}
diff --git a/Frontend/erp-system/types/bank-deposits.ts b/Frontend/erp-system/types/bank-deposits.ts
new file mode 100644
index 0000000..d6b8aca
--- /dev/null
+++ b/Frontend/erp-system/types/bank-deposits.ts
@@ -0,0 +1,108 @@
+// Bank deposits of till cash and the cash in hand behind them (docs/BANK_DEPOSIT_MODULE_PLAN.md).
+// Mirrors Backend/ERPCore/Dtos/Accounts/BankDepositDtos.cs.
+import { PaginationMeta } from "@/types/common"
+
+export type BankDepositStatus = "Posted" | "Cancelled"
+
+/**
+ * One business day's till cash. cashIn = slip/bundle cash + cash invoice payments; cashOut = cash expense
+ * payments; deposited = Posted deposits for that business day. closing = opening + netCash − deposited,
+ * and becomes the next day's opening. Days before tracking starts have opening 0.
+ */
+export interface CashPosition {
+  date: string
+  opening: number
+  cashIn: number
+  cashOut: number
+  netCash: number
+  deposited: number
+  closing: number
+}
+
+export interface CashInHand {
+  position: CashPosition
+  /** Lowest closing from that day up to today — a back-dated deposit lowers every later day too. */
+  availableToDeposit: number
+  branchId: number | null
+  trackingStartDate: string | null
+  timeZone: string
+  /** GL code of the cash account the deposit form preselects. */
+  defaultCashAccountCode: string | null
+}
+
+export interface CashInHandDaily {
+  from: string
+  to: string
+  days: CashPosition[]
+  branchId: number | null
+  trackingStartDate: string | null
+  timeZone: string
+}
+
+export interface BankDeposit {
+  bankDepositId: number
+  docNo: string
+  branchId: number
+  branchName: string | null
+  businessDate: string
+  depositDate: string
+  amount: number
+  fromGlCashAccountId: number
+  fromCashAccountCode: string
+  fromCashAccountName: string
+  toGlBankAccountId: number
+  toBankAccountCode: string
+  toBankAccountName: string
+  toBankName: string | null
+  toAccountNumber: string | null
+  depositSlipNo: string | null
+  depositedBy: string | null
+  remarks: string | null
+  status: BankDepositStatus
+  glJournalNo: string | null
+  glPostedAt: string | null
+  glReversalJournalNo: string | null
+  cancelReason: string | null
+  cancelledAt: string | null
+  createdBy: number
+  createdAt: string
+}
+
+/** A page of deposits plus the total of every row matching the filter. */
+export interface BankDepositList {
+  items: BankDeposit[]
+  pagination: PaginationMeta
+  totalAmount: number
+}
+
+export interface BankDepositListFilterParams {
+  page?: number
+  pageSize?: number
+  q?: string
+  /** Business date range, inclusive. */
+  from?: string
+  to?: string
+  branchId?: number
+  bankAccountId?: number
+  status?: BankDepositStatus
+}
+
+export interface CreateBankDepositRequest {
+  /** Required when branching is enabled; ignored for branch users (always their own branch). */
+  branchId: number
+  businessDate: string
+  /** Omitted ⇒ the business date. */
+  depositDate?: string
+  amount: number
+  fromGlCashAccountId: number
+  toGlBankAccountId: number
+  depositSlipNo?: string
+  depositedBy?: string
+  remarks?: string
+}
+
+/** "0001234567" → "••••4567"; short or missing numbers pass through. */
+export function maskAccountNumber(accountNumber: string | null | undefined): string {
+  if (!accountNumber) return ""
+  return accountNumber.length > 4 ? `••••${accountNumber.slice(-4)}` : accountNumber
+}
diff --git a/Frontend/erp-system/types/bundles.ts b/Frontend/erp-system/types/bundles.ts
index 7719658..e11fd52 100644
--- a/Frontend/erp-system/types/bundles.ts
+++ b/Frontend/erp-system/types/bundles.ts
@@ -92,6 +92,9 @@ export interface BundleSale extends BundleSaleSummary, BundleSaleTotals {
   bundleSaleTemplateId: number
   updatedAt: string | null
   lines: BundleSaleLine[]
+  /** cashAmount + cardAmount === grandTotal (a bundle sale is always fully paid). */
+  cashAmount: number
+  cardAmount: number
 }
 
 export interface BundleSalePostingIssue {
diff --git a/Frontend/erp-system/types/customers.ts b/Frontend/erp-system/types/customers.ts
index c16f97e..f1a7b24 100644
--- a/Frontend/erp-system/types/customers.ts
+++ b/Frontend/erp-system/types/customers.ts
@@ -23,6 +23,12 @@ export interface Customer {
   status: EntityStatus
   createdAt: string
   updatedAt: string | null
+  /** Unpaid balance across Posted sales invoices. Only filled by the list endpoint (0 elsewhere). */
+  outstandingAmount?: number
+  /** Posted sales invoices with a balance still due. Only filled by the list endpoint. */
+  outstandingInvoiceCount?: number
+  /** Latest invoice payment; null if never paid. Only filled by the list endpoint. */
+  lastPaymentDate?: string | null
 }
 
 export interface CreateCustomerRequest {
diff --git a/Frontend/erp-system/types/expenses.ts b/Frontend/erp-system/types/expenses.ts
new file mode 100644
index 0000000..b7e6fd9
--- /dev/null
+++ b/Frontend/erp-system/types/expenses.ts
@@ -0,0 +1,177 @@
+// Expense module types — mirror Backend/ERPCore/Dtos/Expenses/ExpenseDtos.cs
+// (docs/EXPENSE_MODULE_PLAN.md). Dates without a time (expenseDate, dueDate, from/to) are
+// `YYYY-MM-DD`; periodMonth is `YYYY-MM`.
+import { EntityStatus } from "@/types/common"
+
+export type ExpenseStatus = "Draft" | "Posted" | "Cancelled"
+export type ExpensePaymentStatus = "Unpaid" | "PartiallyPaid" | "Paid"
+export type ExpensePaymentMethod = "Cash" | "BankTransfer" | "Cheque" | "Card"
+
+export const expensePaymentMethodLabels: Record<ExpensePaymentMethod, string> = {
+  Cash: "Cash",
+  BankTransfer: "Bank transfer",
+  Cheque: "Cheque",
+  Card: "Card",
+}
+
+export interface ExpenseTitle {
+  expenseTitleId: number
+  expenseCategoryId: number
+  name: string
+  glExpenseAccountCode: string
+  /** Seeded rows keep their name; they can only be deactivated (and have their GL code corrected). */
+  isSystem: boolean
+  status: EntityStatus
+  sortOrder: number
+}
+
+export interface ExpenseCategory {
+  expenseCategoryId: number
+  code: string
+  name: string
+  isSystem: boolean
+  status: EntityStatus
+  sortOrder: number
+  titles: ExpenseTitle[]
+}
+
+export interface UpdateExpenseCategoryRequest {
+  name: string
+  status: EntityStatus
+}
+
+export interface CreateExpenseTitleRequest {
+  name: string
+  glExpenseAccountCode: string
+}
+
+export interface UpdateExpenseTitleRequest {
+  name: string
+  glExpenseAccountCode: string
+  status: EntityStatus
+}
+
+export interface ExpenseSummary {
+  expenseId: number
+  docNo: string
+  branchId: number
+  expenseDate: string
+  dueDate: string | null
+  expenseCategoryId: number
+  categoryName: string
+  expenseTitleId: number
+  titleName: string
+  payee: string | null
+  billReference: string | null
+  periodMonth: string | null
+  amount: number
+  paidAmount: number
+  balanceAmount: number
+  status: ExpenseStatus
+  paymentStatus: ExpensePaymentStatus
+  glJournalNo: string | null
+  createdAt: string
+}
+
+export interface ExpensePayment {
+  expensePaymentId: number
+  expenseId: number
+  amount: number
+  paymentDate: string
+  paymentMethod: ExpensePaymentMethod
+  glBankAccountId: number
+  bankAccountName: string
+  chequeNo: string | null
+  reference: string | null
+  /** Shared by every line of one payment submission (one GL entry per submission). */
+  glJournalNo: string | null
+  createdAt: string
+}
+
+export interface Expense extends ExpenseSummary {
+  vendorId: number | null
+  vendorName: string | null
+  description: string | null
+  glExpenseAccountCode: string | null
+  glPostedAt: string | null
+  glReversalJournalNo: string | null
+  cancelReason: string | null
+  createdBy: number
+  updatedAt: string | null
+  payments: ExpensePayment[]
+}
+
+export interface CreateExpenseRequest {
+  /** 0 ⇒ the server resolves the default branch. */
+  branchId: number
+  expenseDate: string
+  dueDate?: string | null
+  expenseCategoryId: number
+  expenseTitleId: number
+  payee?: string | null
+  vendorId?: number | null
+  billReference?: string | null
+  description?: string | null
+  periodMonth?: string | null
+  amount: number
+}
+
+export type UpdateExpenseRequest = CreateExpenseRequest
+
+export interface ExpensePaymentLineRequest {
+  glBankAccountId: number
+  amount: number
+}
+
+export interface CreateExpensePaymentRequest {
+  lines: ExpensePaymentLineRequest[]
+  paymentMethod: ExpensePaymentMethod
+  /** Required when paymentMethod is Cheque. */
+  chequeNo?: string | null
+  reference?: string | null
+  /** `YYYY-MM-DD`; omitted ⇒ today; never future. */
+  paymentDate?: string
+}
+
+export interface ExpenseListFilterParams {
+  page?: number
+  pageSize?: number
+  q?: string
+  status?: ExpenseStatus
+  paymentStatus?: ExpensePaymentStatus
+  categoryId?: number
+  titleId?: number
+  from?: string
+  to?: string
+  overdueOnly?: boolean
+}
+
+export interface ExpenseTitleTotal {
+  expenseTitleId: number
+  titleName: string
+  amount: number
+  count: number
+}
+
+export interface ExpenseCategoryTotal {
+  expenseCategoryId: number
+  categoryName: string
+  amount: number
+  count: number
+  titles: ExpenseTitleTotal[]
+}
+
+export interface ExpenseSummaryReport {
+  from: string
+  to: string
+  totalAmount: number
+  paidAmount: number
+  unpaidAmount: number
+  count: number
+  /** All-time unpaid balance of Posted expenses (not limited to from/to). */
+  outstandingAmount: number
+  overdueAmount: number
+  overdueCount: number
+  draftCount: number
+  categories: ExpenseCategoryTotal[]
+}
diff --git a/Frontend/erp-system/types/grn.ts b/Frontend/erp-system/types/grn.ts
index e4aee38..16fc33f 100644
--- a/Frontend/erp-system/types/grn.ts
+++ b/Frontend/erp-system/types/grn.ts
@@ -1,10 +1,7 @@
 // Goods Receipt Note types (docs/11-BACKEND-PHASE1.md §4; FR-GRN-01..08).
 // Mirrors the live backend DTOs. GET /grns and GET /grns/{id} both exist as of 2026-07-16.
-//
-// KNOWN GAP — serial numbers: FR-GRN-04 requires capturing serial numbers on receipt for
-// Serial-tracked items, but the backend's CreateGrnLineInput has no such field (only
-// `batch`). There is therefore deliberately no `serialNumbers` here: typing it would
-// invite the UI to send data the server silently drops. Tracked in Frontend/PROGRESS.md.
+// Serial numbers (FR-GRN-04) are captured per unit for Serial-tracked items — see
+// docs/ITEM_TRACKING_PLAN.md Phase 2.
 
 export type GrnStatus = "Draft" | "Confirmed" | "Closed"
 export type HoldStatus = "OnHold" | "Available" | "Rejected"
@@ -51,9 +48,15 @@ export interface CreateGrnLineInput {
   batch?: BatchInput | null
   /**
    * Required, one per received unit (count must equal `qty`), when the item is
-   * warranty-tracked (`Item.warranty === "Warranty"`). Ignored otherwise.
+   * warranty-tracked (`Item.warranty === "Warranty"`) and NOT serial-tracked — a serial
+   * item's serial number is its warranty identity. Ignored otherwise.
    */
   warrantyNumbers?: string[] | null
+  /**
+   * Required, one per received unit (qty must be whole), when the item is serial-tracked
+   * (`Item.trackingMode === "Serial"`). Rejected for any other item.
+   */
+  serialNumbers?: string[] | null
 }
 
 export interface CreateGrnRequest {
@@ -90,6 +93,15 @@ export interface GrnLine {
   holdStatus: HoldStatus
   batchId: number | null
   warrantyNumbers: GrnLineWarrantyNumber[]
+  batchNo: string | null
+  batchExpiryDate: string | null
+  /** Serials captured on the line; `serialId` is set once the GRN is confirmed. */
+  serials: GrnLineSerial[]
+}
+
+export interface GrnLineSerial {
+  serialNo: string
+  serialId: number | null
 }
 
 export interface Grn {
diff --git a/Frontend/erp-system/types/master-data.ts b/Frontend/erp-system/types/master-data.ts
index e96735b..5b2a1d0 100644
--- a/Frontend/erp-system/types/master-data.ts
+++ b/Frontend/erp-system/types/master-data.ts
@@ -82,6 +82,21 @@ export interface ItemOverview {
   salesQtyLast30Days: number
 }
 
+/** One posted GRN receipt of an item. `netUnitCost` = unit cost after trade discount, VAT excluded — the stock cost. */
+export interface ItemPurchasePrice {
+  grnId: number
+  grnDocNo: string
+  receivedAt: string
+  vendorId: number
+  vendorName: string | null
+  warehouseCode: string | null
+  qty: number
+  unitCost: number
+  discountPct: number
+  netUnitCost: number
+  vatPct: number
+}
+
 export interface ItemReorderSetting {
   warehouseId: number
   reorderPoint: number
diff --git a/Frontend/erp-system/types/procurement.ts b/Frontend/erp-system/types/procurement.ts
index 2746429..20b943e 100644
--- a/Frontend/erp-system/types/procurement.ts
+++ b/Frontend/erp-system/types/procurement.ts
@@ -265,6 +265,8 @@ export interface CreatePurchaseReturnLineInput {
   grnLineId?: number | null
   itemId: number
   qty: number
+  /** Serial-tracked item: the serials sent back (become ReturnedToVendor). */
+  serialIds?: number[] | null
 }
 
 export interface CreatePurchaseReturnRequest {
diff --git a/Frontend/erp-system/types/purchase-invoices.ts b/Frontend/erp-system/types/purchase-invoices.ts
index 4c56ddb..d6a57ba 100644
--- a/Frontend/erp-system/types/purchase-invoices.ts
+++ b/Frontend/erp-system/types/purchase-invoices.ts
@@ -64,6 +64,8 @@ export interface CreatePurchaseInvoicePaymentRequest {
   amount: number
   glBankAccountId: number
   reference?: string | null
+  /** `YYYY-MM-DD`; when the vendor was paid (also the GL entry date). Omitted ⇒ today; never future. */
+  paymentDate?: string
 }
 
 export interface CreatePurchaseInvoiceRequest {
diff --git a/Frontend/erp-system/types/sales.ts b/Frontend/erp-system/types/sales.ts
index d08046e..006e8fb 100644
--- a/Frontend/erp-system/types/sales.ts
+++ b/Frontend/erp-system/types/sales.ts
@@ -1,3 +1,4 @@
+import { SalesLineSerial } from "@/types/tracking"
 import { EntityStatus } from "@/types/common"
 
 export type SalesInvoiceType = "B2B" | "B2C" | "Cash" | "Credit"
@@ -24,6 +25,8 @@ export interface SalesInvoiceLine {
   taxAmount: number
   isFreeIssue: boolean
   parentLineId: number | null
+  batchId: number | null
+  serials: SalesLineSerial[]
 }
 
 export interface SalesInvoiceTotals {
@@ -164,11 +167,24 @@ export interface SalesInvoicePayment {
   reference: string | null
   glJournalNo: string | null
   createdAt: string
+  paymentMethod: SalesPaymentMethod
+}
+
+/** How a customer paid — drives the Day-End Report's cash/card split. */
+export type SalesPaymentMethod = "Cash" | "Card" | "BankTransfer" | "Cheque"
+
+export const salesPaymentMethodLabels: Record<SalesPaymentMethod, string> = {
+  Cash: "Cash",
+  Card: "Card",
+  BankTransfer: "Bank transfer",
+  Cheque: "Cheque",
 }
 
 export interface CreateSalesInvoicePaymentRequest {
   amount: number
   glBankAccountId: number
+  /** Omitted ⇒ the backend derives it from the account (Cash account ⇒ Cash, Bank ⇒ Card). */
+  paymentMethod?: SalesPaymentMethod
   reference?: string | null
   /** `YYYY-MM-DD`; when the customer paid (also the GL entry date). Omitted ⇒ today; never future. */
   paymentDate?: string
@@ -177,7 +193,7 @@ export interface CreateSalesInvoicePaymentRequest {
 /** Pay several Posted invoices of one (non-cash) customer at once; applied oldest invoice first. */
 export interface CreateBulkSalesInvoicePaymentRequest {
   salesInvoiceIds: number[]
-  lines: { amount: number; glBankAccountId: number }[]
+  lines: { amount: number; glBankAccountId: number; paymentMethod?: SalesPaymentMethod }[]
   reference?: string | null
   /** `YYYY-MM-DD`; omitted ⇒ today; never future. */
   paymentDate?: string
@@ -197,6 +213,10 @@ export interface CreateSalesInvoiceLineRequest {
   taxPct: number
   isFreeIssue: boolean
   parentLineId?: number | null
+  /** Pins one batch; omit to let posting pick FEFO. */
+  batchId?: number | null
+  /** Serial-tracked item: one in-stock serial per unit of qty + freeQty. */
+  serialIds?: number[] | null
 }
 
 export interface CreateSalesInvoiceRequest {
@@ -230,6 +250,9 @@ export interface SalesSlipLine {
   taxAmount: number
   isFreeIssue: boolean
   parentLineId: number | null
+  batchId: number | null
+  serialId: number | null
+  serials: SalesLineSerial[]
 }
 
 export interface SalesSlipTotals {
@@ -240,6 +263,9 @@ export interface SalesSlipTotals {
   grandTotal: number
   paidAmount: number
   balanceAmount: number
+  /** cashAmount + cardAmount === paidAmount. */
+  cashAmount: number
+  cardAmount: number
 }
 
 export interface SalesSlipSummary {
@@ -283,6 +309,12 @@ export interface CreateSalesSlipLineRequest {
   taxPct: number
   isFreeIssue: boolean
   parentLineId?: number | null
+  /** Pins one batch; omit to let posting pick FEFO. */
+  batchId?: number | null
+  /** Legacy single-serial pin; prefer `serialIds`. */
+  serialId?: number | null
+  /** Serial-tracked item: one in-stock serial per unit of qty + freeQty. */
+  serialIds?: number[] | null
 }
 
 export interface CreateSalesSlipRequest {
@@ -292,6 +324,8 @@ export interface CreateSalesSlipRequest {
   lines: CreateSalesSlipLineRequest[]
   /** Omit for the default: fully paid (paidAmount === grandTotal, balanceAmount === 0). */
   paidAmount?: number | null
+  /** The part of paidAmount tendered by card (the rest is cash). Omit for all cash. */
+  cardAmount?: number | null
 }
 
 export type UpdateSalesSlipRequest = CreateSalesSlipRequest
@@ -409,6 +443,9 @@ export interface SalesReturnLine {
   salesInvoiceLineId: number | null
   itemId: number
   qty: number
+  /** Batch restocked into — the batch the goods were sold from. */
+  batchId: number | null
+  serials: SalesLineSerial[]
 }
 
 export interface SalesReturn {
@@ -444,12 +481,28 @@ export interface SalesReturnSummary {
 export interface SalesInvoiceLineRemaining {
   salesInvoiceLineId: number
   remainingQty: number
+  /** What the posted line actually issued (batch/serial), net of returns — what a return can take back. */
+  allocations: SalesLineAllocation[]
+}
+
+export interface SalesLineAllocation {
+  batchId: number | null
+  batchNo: string | null
+  expiryDate: string | null
+  serialId: number | null
+  serialNo: string | null
+  qty: number
+  qtyReturned: number
 }
 
 export interface CreateSalesReturnLineInput {
   salesInvoiceLineId?: number | null
   itemId: number
   qty: number
+  /** Batch to restock into; optional when the line issued a single batch. */
+  batchId?: number | null
+  /** Serial-tracked item: the returned serials, one per unit. */
+  serialIds?: number[] | null
 }
 
 export interface CreateSalesReturnRequest {
@@ -457,6 +510,8 @@ export interface CreateSalesReturnRequest {
   warehouseId: number
   /** Mandatory; omitting it returns 400 REASON_CODE_REQUIRED. */
   reasonCodeId: number
+  /** Returned serials become Damaged instead of InStock. Omit to derive from the reason (DEF/QREJ ⇒ damaged). */
+  markDamaged?: boolean | null
   lines: CreateSalesReturnLineInput[]
 }
 
@@ -558,3 +613,97 @@ export interface CreateSalesDayEndRequest {
   cashierUserId: number
   businessDate?: string | null
 }
+
+// Day-End Sales Report (docs/DAY_END_SALES_REPORT_PLAN.md) ---------------------------------------
+
+/** One business day's figures — or, with `date` null, a range's totals. Income = totalSales − expenseTotal. */
+export interface DayEndReportDay {
+  date: string | null
+  totalSales: number
+  paidAmount: number
+  dueAmount: number
+  paidByCash: number
+  paidByCard: number
+  /** Bank transfer + cheque. */
+  paidByOther: number
+  salesCount: number
+  cashSalesCount: number
+  cardSalesCount: number
+  /** Paid more than one way (e.g. part cash, part card). */
+  mixedSalesCount: number
+  otherSalesCount: number
+  unpaidSalesCount: number
+  expenseTotal: number
+  income: number
+  /** FIFO cost of the stock the day's sales issued. */
+  costOfGoodsSold: number
+  /** totalSales − costOfGoodsSold. */
+  grossProfit: number
+  /** grossProfit − expenseTotal; negative is a loss. */
+  netProfit: number
+  /** Payments received this day on invoices from earlier days — not part of paidAmount. */
+  earlierInvoiceCollections: number
+  /** Cash in this day minus expenses paid in cash this day — a till check. */
+  netCash: number
+  /** Cash left in the till from earlier days (Bank Deposit module). For a range's totals, the first day's. */
+  openingCashInHand: number
+  /** Posted bank deposits made against this business day. */
+  cashDeposited: number
+  /** openingCashInHand + netCash − cashDeposited: still in hand. For a range's totals, the last day's. */
+  closingCashInHand: number
+}
+
+/** A Posted bank deposit of the day's cash. */
+export interface DayEndReportDeposit {
+  bankDepositId: number
+  docNo: string
+  bankAccountName: string
+  bankName: string | null
+  accountNumber: string | null
+  depositSlipNo: string | null
+  depositDate: string
+  amount: number
+}
+
+export interface DayEndReportExpense {
+  expenseId: number
+  docNo: string
+  categoryName: string
+  titleName: string
+  payee: string | null
+  amount: number
+  paidAmount: number
+}
+
+export interface DayEndReportSale {
+  docType: "Invoice" | "Slip" | "Bundle"
+  docId: number
+  docNo: string
+  at: string
+  customerName: string
+  total: number
+  paid: number
+  due: number
+  /** Cash, Card, Bank transfer, Cheque, Mixed or Unpaid. */
+  paidBy: string
+  cost: number
+  grossProfit: number
+}
+
+export interface DayEndReport {
+  summary: DayEndReportDay
+  sales: DayEndReportSale[]
+  expenses: DayEndReportExpense[]
+  deposits: DayEndReportDeposit[]
+  branchId: number | null
+  timeZone: string
+}
+
+export interface DayEndDailyReport {
+  from: string
+  to: string
+  days: DayEndReportDay[]
+  totals: DayEndReportDay
+  branchId: number | null
+  timeZone: string
+}
diff --git a/Frontend/erp-system/types/stock.ts b/Frontend/erp-system/types/stock.ts
index 186e2e0..6278a17 100644
--- a/Frontend/erp-system/types/stock.ts
+++ b/Frontend/erp-system/types/stock.ts
@@ -1,6 +1,7 @@
 // Stock Management types (docs/11-BACKEND-PHASE1.md §5; FR-STK-01..14, FR-WH-*).
 // Mirrors the live backend DTOs. The list endpoints (GET /stock-transfers,
 // /stock-adjustments, /stock-counts, /stock/on-hand/list) all exist as of 2026-07-16.
+import { ApprovalStep } from "@/types/approvals"
 import { Requisition } from "@/types/procurement"
 
 export type Currency = "LKR"
@@ -76,6 +77,8 @@ export interface TransferLine {
   qty: number
   /** Accrues on partial receive; qty - qtyReceived is what is still in transit. */
   qtyReceived: number
+  /** Serial-tracked item: the units moved; `received` once each has arrived. */
+  serials: { serialId: number; serialNo: string; received: boolean }[]
 }
 
 export interface StockTransfer {
@@ -106,8 +109,11 @@ export interface CreateTransferLineInput {
   itemId: number
   srcBinId?: number | null
   destBinId?: number | null
+  /** Omit for a batch-tracked item to have the server split the line FEFO across batches. */
   batchId?: number | null
   qty: number
+  /** Serial-tracked item: one in-stock serial (at the source) per unit. */
+  serialIds?: number[] | null
 }
 
 export interface CreateTransferRequest {
@@ -136,6 +142,8 @@ export interface DispatchTransferResponse {
 export interface ReceiveTransferLineInput {
   transferLineId: number
   qty: number
+  /** Serial line: which in-transit serials arrived; omit when receiving all outstanding. */
+  serialIds?: number[] | null
 }
 
 export interface ReceiveTransferRequest {
@@ -158,9 +166,12 @@ export interface ReceiveTransferResponse {
 
 // --- 5.5 Adjustments ------------------------------------------------------------------
 
-/** Phase 1 auto-posts, so `Posted` is what you see; the other two exist for the deferred
- *  approval workflow (FR-STK-07) and are in the server enum. */
-export type AdjustmentStatus = "Draft" | "PendingApproval" | "Posted"
+/**
+ * An adjustment is a request until approved (docs/DUAL_APPROVAL_PLAN.md §5): PendingApproval →
+ * (PendingSecondApproval →) Posted, or Rejected / Cancelled. It moves stock only when Posted.
+ * With approvals switched off it is Posted straight away.
+ */
+export type AdjustmentStatus = "Draft" | "PendingApproval" | "PendingSecondApproval" | "Posted" | "Rejected" | "Cancelled"
 
 export interface AdjustmentLine {
   adjLineId: number
@@ -169,6 +180,10 @@ export interface AdjustmentLine {
   batchId: number | null
   /** Signed: negative FIFO-consumes, positive creates a layer. */
   qtyDelta: number
+  serialId: number | null
+  /** Serials named on the request (shown while it waits for approval). */
+  requestedSerialIds?: number[] | null
+  requestedSerialNos?: string[] | null
 }
 
 export interface StockAdjustment {
@@ -183,6 +198,23 @@ export interface StockAdjustment {
   glPostedAt: string | null
   lines: AdjustmentLine[]
   ledgerRefs: number[]
+  /** 0 = posted without approval, 1 or 2. */
+  requiredApprovals: number
+  /** The approval it waits for (1 or 2); null once decided. */
+  pendingLevel: number | null
+  approvedLevel1By: number | null
+  approvedLevel1At: string | null
+  approvedLevel2By: number | null
+  approvedLevel2At: string | null
+  rejectedBy: number | null
+  rejectedAt: string | null
+  rejectReason: string | null
+  postedAt: string | null
+  approvalHistory: ApprovalStep[] | null
+  canApprove: boolean
+  whyNot: string | null
+  canWithdraw: boolean
+  createdByName: string | null
 }
 
 export interface StockAdjustmentSummary {
@@ -195,6 +227,8 @@ export interface StockAdjustmentSummary {
   createdAt: string
   lineCount: number
   glJournalNo: string | null
+  requiredApprovals: number
+  pendingLevel: number | null
 }
 
 export interface CreateAdjustmentLineInput {
@@ -202,6 +236,10 @@ export interface CreateAdjustmentLineInput {
   binId?: number | null
   batchId?: number | null
   qtyDelta: number
+  /** Negative delta, serial item: the serials written off (become Scrapped). */
+  serialIds?: number[] | null
+  /** Positive delta, serial item: the serial numbers found (created, or brought back InStock). */
+  serialNos?: string[] | null
 }
 
 export interface CreateAdjustmentRequest {
@@ -275,9 +313,12 @@ export interface PostCountResponse {
   status: CountStatus
   /** Null when the count had no variance to post. */
   adjustmentId: number | null
-  /** Null when there was no variance, or the variance's value was 0 either way. */
+  /** Null when there was no variance, or the variance's value was 0 either way — and while it waits for approval. */
   glJournalNo: string | null
   ledgerRefs: number[]
+  /** The variance adjustment's status: PendingApproval when it must be approved before stock moves. */
+  adjustmentStatus?: AdjustmentStatus | null
+  adjustmentDocNo?: string | null
 }
 
 // --- 5.7 Reorder alerts ------------------------------------------------------------------
diff --git a/Frontend/erp-system/types/tracking.ts b/Frontend/erp-system/types/tracking.ts
new file mode 100644
index 0000000..260d596
--- /dev/null
+++ b/Frontend/erp-system/types/tracking.ts
@@ -0,0 +1,120 @@
+// Item tracking — serials, batches, warranty (docs/ITEM_TRACKING_PLAN.md Phases 5, 8, 9).
+// Mirrors Backend Dtos/Stock/TrackingDtos.cs.
+
+export type SerialStatus =
+  | "InStock"
+  | "Reserved"
+  | "InTransit"
+  | "Sold"
+  | "ReturnedByCustomer"
+  | "ReturnedToVendor"
+  | "Damaged"
+  | "Scrapped"
+  /** Left stock without being named while serial numbers were switched off. */
+  | "IssuedUntracked"
+
+export type WarrantyStatus = "Active" | "Voided" | "Claimed"
+
+/** Product Configuration switches every screen can read (GET /tracking/settings). */
+export interface TrackingSettings {
+  serialNumbersEnabled: boolean
+}
+
+/** A serial chosen on (or sold by) a sales line. */
+export interface SalesLineSerial {
+  serialId: number
+  serialNo: string
+}
+
+export interface AvailableSerial {
+  serialId: number
+  serialNo: string
+  batchId: number | null
+  batchNo: string | null
+  status: SerialStatus
+}
+
+export interface AvailableBatch {
+  batchId: number | null
+  batchNo: string | null
+  /** `YYYY-MM-DD` */
+  expiryDate: string | null
+  qty: number
+  daysToExpiry: number | null
+}
+
+export interface BatchSuggestion {
+  batchId: number | null
+  batchNo: string | null
+  expiryDate: string | null
+  qty: number
+}
+
+export interface SerialSummary {
+  serialId: number
+  itemId: number
+  sku: string
+  itemName: string
+  serialNo: string
+  status: SerialStatus
+  warehouseId: number | null
+  warehouseName: string | null
+  binId: number | null
+  receivedAt: string | null
+  grnId: number | null
+  grnDocNo: string | null
+  warrantyPeriodMonths: number | null
+}
+
+export interface SerialMovement {
+  serialMovementId: number
+  /** Document-type prefix (GRN, SI, SSL, SRET, PRET, TRF, ADJ, CNT). */
+  sourceDocType: string
+  sourceDocId: number
+  status: SerialStatus
+  fromWarehouseId: number | null
+  warehouseId: number | null
+  userId: number
+  createdAt: string
+}
+
+export interface WarrantyRegistration {
+  warrantyRegistrationId: number
+  itemId: number
+  sku: string
+  itemName: string
+  serialId: number | null
+  serialNo: string | null
+  customerId: number
+  customerName: string
+  sourceDocType: string
+  sourceDocId: number
+  sourceLineId: number
+  qty: number
+  startDate: string
+  periodMonths: number
+  endDate: string
+  status: WarrantyStatus
+  daysRemaining: number
+  isExpired: boolean
+}
+
+export interface SerialDetail {
+  serial: SerialSummary
+  history: SerialMovement[]
+  warranties: WarrantyRegistration[]
+}
+
+export interface BatchStock {
+  itemId: number
+  sku: string
+  itemName: string
+  warehouseId: number
+  warehouseName: string
+  batchId: number | null
+  batchNo: string | null
+  expiryDate: string | null
+  qty: number
+  daysToExpiry: number | null
+  isExpired: boolean
+}
diff --git a/docs/BANK_DEPOSIT_MODULE_PLAN.md b/docs/BANK_DEPOSIT_MODULE_PLAN.md
new file mode 100644
index 0000000..f342cde
--- /dev/null
+++ b/docs/BANK_DEPOSIT_MODULE_PLAN.md
@@ -0,0 +1,316 @@
+# Bank Deposit Module Plan
+
+> **Status:** implemented 2026-10-08 with the §12 defaults. Deviations: one `NAV:accounts.bank-deposits` permission
+> with `Create`/`Delete` action suffixes instead of three codes (§6); the nav item sorts last under Accounts; the
+> day-wise PDF gets a separate cash table rather than two more columns (§9). Details in `Backend/PROGRESS.md` and
+> `Frontend/PROGRESS.md`.
+> **Lives under:** the existing **Accounts** nav item (`NavItemId = 12`, `/dashboard/accounts`), next to
+> Cash / Bank Accounts, Cheque Books, Received Cheques and Expenses.
+> **GL transport:** `docs/12-GENERAL-LEDGER-INTEGRATION.md` (typed calls via `IGeneralLedgerService`).
+> **Reference implementation to mirror:** `ExpensePaymentService`. It calls GL before commit, so a failed post
+> rolls back the whole operation.
+> **Consumers:** the Day-End Sales Report (`docs/DAY_END_SALES_REPORT_PLAN.md`) reads deposit figures from this
+> module (§9). The report itself does not own any deposit logic.
+
+---
+
+## 1. Goal
+
+At the end of a business day, the cash collected in the till is taken to the bank. Users can:
+
+- see the **cash in hand** for a branch and day: what came in as cash, what went out as cash, what was already deposited, and what is left,
+- record a **deposit** of that cash into a chosen **bank account**,
+- **cancel** a wrong deposit, which reverses its GL entry,
+- list deposits by date, branch and bank account.
+
+**Only cash is deposited.** Card, bank-transfer and cheque receipts never sit in the till, so this module ignores them.
+Cheques have their own Received Cheques flow.
+
+Every deposit posts a real GL journal entry that moves the money from the cash account to the bank account.
+
+---
+
+## 2. Concepts
+
+```
+Cash in (per branch, per local day)
+   ├── Sales slips / bundle sales     → CashAmount
+   └── Sales invoice payments         → PaymentMethod = Cash
+Cash out
+   └── Expense payments               → PaymentMethod = Cash
+                       │
+                       ▼
+            Cash in hand (running balance, carried day to day)
+                       │
+                       ▼
+BankDeposit  (Cash account ──► Bank account, posts GL, reduces cash in hand)
+```
+
+For branch *B* and local day *D*:
+
+```
+NetCash(D)    = CashIn(D) − CashOut(D)
+Deposited(D)  = Σ Posted BankDeposit.Amount where BusinessDate = D
+Opening(D)    = Σ NetCash(d) − Σ Deposited(d)       for CashTrackingStartDate ≤ d < D
+Closing(D)    = Opening(D) + NetCash(D) − Deposited(D)     ← "remaining cash in hand"
+```
+
+`NetCash(D)` is the same figure the Day-End Sales Report already shows. This module adds the carry-forward and the deposits on top of it.
+
+---
+
+## 3. Current state
+
+| Area | What exists | Gap |
+|---|---|---|
+| Cash/bank accounts | Kept in GL. `ListBankAccountsAsync` returns `GlBankAccount` (`AccountType` = `Cash`/`Bank`, `AccountName`, `BankName`, `AccountNumber`, `GlAccountCode`). The UI is at `/dashboard/accounts/bank-accounts`. | — |
+| Cash received | Slips and bundles have `CashAmount`. `SalesInvoicePayment.PaymentMethod` exists. | — |
+| Cash paid | `ExpensePayment.PaymentMethod = Cash` | — |
+| Net cash | Computed inline in `DayEndReportService.LoadAsync` | Not reusable. Not carried forward between days. |
+| Deposits | — | No entity, service, API or screen. |
+
+---
+
+## 4. Data model (backend)
+
+### 4.1 `Domain/Entities/BankDeposit.cs`
+
+| Field | Type | Notes |
+|---|---|---|
+| `BankDepositId` | int | PK |
+| `DocNo` | string | `DocumentTypes.BankDeposit` (prefix `BD`) |
+| `BranchId` / `Branch` | int | The branch whose till the cash came from |
+| `BusinessDate` | DateOnly | The day whose cash is deposited. Cash in hand and the day-end report group by this date. |
+| `DepositDate` | DateOnly | The day the bank received the money. Used as the GL entry date. Defaults to `BusinessDate`. |
+| `Amount` | decimal(18,2) | > 0 |
+| `FromGlCashAccountId` / `FromCashAccountCode` / `FromCashAccountName` | long / string | A GL account with `AccountType = Cash`. Snapshots, because GL accounts have no local FK. |
+| `ToGlBankAccountId` / `ToBankAccountCode` / `ToBankAccountName` / `ToBankName` / `ToAccountNumber` | long / string | A GL account with `AccountType = Bank`. Snapshots. |
+| `DepositSlipNo` | string? | The reference on the bank's deposit slip |
+| `DepositedBy` | string? | The person who took the cash to the bank |
+| `Remarks` | string? | |
+| `Status` | `BankDepositStatus` | `Posted`, `Cancelled` (new enum in `Domain/Enums`) |
+| `GlJournalNo`, `GlPostedAt` | | The posting entry |
+| `GlReversalJournalNo`, `CancelReason`, `CancelledBy`, `CancelledAt` | | Cancellation |
+| `CreatedBy`, `CreatedAt`, `RowVersion` | | Same as `Expense` |
+
+There is no Draft state. A deposit is entered after the cash has actually been handed over, so saving it
+posts it. A mistake is fixed by cancelling and re-entering.
+
+### 4.2 Configuration & migration
+
+- `Infra/Persistence/Configurations/BankDepositConfiguration.cs`:
+  - Index `(BranchId, BusinessDate, Status)`.
+  - Unique `DocNo`.
+  - `CHECK (Amount > 0)`, quoted the MariaDB-safe way (see commit `c97a7e9`).
+- Add `DbSet<BankDeposit>` to `ErpDbContext`.
+- Migration `AddBankDepositModule`:
+  - Creates the table.
+  - Seeds the `BD` document-number row.
+  - Seeds the permissions and nav item (§6).
+  - Grants them to the roles that already reach Accounts (same pattern as `GrantExpensePermissions`).
+
+---
+
+## 5. Settings (`appsettings.json`)
+
+```json
+"BankDeposit": {
+  "DefaultCashAccountCode": "1000-01",
+  "CashTrackingStartDate": "2026-10-01"
+}
+```
+
+- **`DefaultCashAccountCode`** preselects the "from" account on the form. It is the same cash account that `SalesDayEnd` debits.
+- **`CashTrackingStartDate`** is the day the running cash-in-hand balance starts. Earlier sales had no reliable cash/card split.
+- The local day comes from the existing `DayEndReport:TimeZone` setting, so both features agree on what "today" means.
+
+---
+
+## 6. Permissions & navigation
+
+| Code | Purpose |
+|---|---|
+| `accounts.bank-deposits` | View the list, the details and the cash in hand. Also the nav entry. |
+| `accounts.bank-deposits.create` | Record a deposit |
+| `accounts.bank-deposits.cancel` | Cancel a deposit |
+
+- Add the nav entry to `SubNavItemConfiguration` under Accounts (`NavItemId = 12`), href `/dashboard/accounts/bank-deposits`, placed after Cash / Bank Accounts.
+- Add the matching permission rows to `PermissionConfiguration`.
+
+---
+
+## 7. Backend services & API
+
+### 7.1 `CashInHandService` / `ICashInHandService` (owned by this module)
+
+This service is the single source for cash in hand. Both the deposit form and the Day-End Sales Report call it.
+
+```csharp
+Task<CashPositionDto> GetPositionAsync(DateOnly day, int? branchId, CancellationToken ct);
+Task<IReadOnlyList<CashPositionDto>> GetRangeAsync(DateOnly from, DateOnly to, int? branchId, CancellationToken ct);
+
+// CashPositionDto(Date, Opening, CashIn, CashOut, NetCash, Deposited, Closing)
+```
+
+- **Moving the logic:** move the cash queries out of `DayEndReportService.LoadAsync` into this service: slip/bundle `CashAmount`, cash invoice payments, and cash expense payments.
+- **Opening balance:** `Opening(from)` is computed with a few `SumAsync` queries over `[CashTrackingStartDate, from)`. Those queries cover cash in, cash out and posted deposits. Days inside the range are then rolled forward in memory.
+- **Shared date helpers:** move the local-day to UTC-window helpers (`ToUtc`, `LocalDay`, `ResolveZone`) into a small shared `BusinessDayClock` so the two services cannot drift apart.
+- **Branch scope:** branch-scoped users always get their own branch (`ICurrentBranchContext`).
+
+### 7.2 `BankDepositService` / `IBankDepositService`
+
+**`CreateAsync(CreateBankDepositRequest)`**
+
+Request: `BranchId, BusinessDate, DepositDate?, Amount, FromGlCashAccountId, ToGlBankAccountId, DepositSlipNo?, DepositedBy?, Remarks?`
+
+1. Resolve the effective branch.
+2. Check the accounts with `_gl.ListBankAccountsAsync`:
+   - The "from" account must be `Cash`. Otherwise fail with `BankDepositCashAccountInvalid`.
+   - The "to" account must be `Bank`. Otherwise fail with `BankDepositBankAccountInvalid`.
+3. Check the dates:
+   - `CashTrackingStartDate ≤ BusinessDate ≤ today`.
+   - `BusinessDate ≤ DepositDate ≤ tomorrow`.
+   - Otherwise fail with `BankDepositDateInvalid`.
+4. Check the balance:
+   - `Amount ≤ Closing(BusinessDate)`. Otherwise fail with `BankDepositExceedsCashInHand` (400), and include the available amount in the message.
+   - A back-dated deposit must also not push any later day's `Closing` below zero.
+5. In `_uow.ExecuteInTransactionAsync`, re-check the balance inside the transaction (two cashiers may deposit at the same time), then post to GL before saving:
+   ```
+   SourceModule = "BANK_DEPOSIT", Reference = DocNo, EntryDate = DepositDate
+   Dr  ToBankAccountCode    Amount   "Cash deposit {DocNo} — {BusinessDate:yyyy-MM-dd}"
+   Cr  FromCashAccountCode  Amount
+   ```
+
+**`CancelAsync(id, reason)`:** the deposit must be Posted. Post the reversing journal (Dr cash / Cr bank) and set `Cancelled`.
+Cancelling only puts cash back in hand, so it needs no balance check.
+
+**Read methods**
+
+- **`ListAsync(filter)`:** filter by date range on `BusinessDate`, branch, bank account and status. Paged, with the filtered total.
+- **`GetAsync(id)`**
+
+### 7.3 `Controllers/BankDepositsController.cs`, route `api/v1/bank-deposits`
+
+| Method | Route | Permission |
+|---|---|---|
+| GET | `/` | `accounts.bank-deposits` |
+| GET | `/{id}` | `accounts.bank-deposits` |
+| GET | `/cash-in-hand?date=&branchId=` | `accounts.bank-deposits` |
+| GET | `/cash-in-hand/daily?from=&to=&branchId=` | `accounts.bank-deposits` (≤ 92 days) |
+| POST | `/` | `accounts.bank-deposits.create` |
+| POST | `/{id}/cancel` | `accounts.bank-deposits.cancel` |
+
+### 7.4 Wiring
+
+- Add `DocumentTypes.BankDeposit = "BD"`.
+- Add to `ErrorCodes`:
+  - `BankDepositCashAccountInvalid`
+  - `BankDepositBankAccountInvalid`
+  - `BankDepositExceedsCashInHand`
+  - `BankDepositDateInvalid`
+  - `BankDepositNotCancellable`
+- Add DTOs in `Dtos/Accounts/BankDepositDtos.cs`.
+- Register `ICashInHandService` and `IBankDepositService` in `Program.cs`.
+
+---
+
+## 8. Frontend (`/dashboard/accounts/bank-deposits`)
+
+- **API and types:** `lib/api/bank-deposits.ts`, `types/bank-deposits.ts`.
+- **Accounts hub:** add a **Bank Deposits** card to `app/dashboard/accounts/page.tsx`, and add the entry to `AppSidebar.tsx`, gated by `accounts.bank-deposits`.
+
+**List page**
+
+- Filters: date range, branch, bank account, status.
+- Table columns: Doc No · Business Date · Deposit Date · Branch · Bank Account (name, bank, masked number) · Slip No · Amount · Status.
+- Footer total.
+- **New Deposit** button.
+
+**New page (`/new`)**
+
+- **Branch** and **business date**. Changing either refetches `/cash-in-hand`.
+- **Cash position panel:** Opening · Cash in · Cash out · Already deposited · **Available to deposit**.
+- **From cash account:** `Cash` accounts only. Defaults to `DefaultCashAccountCode`.
+- **To bank account:** `Bank` accounts only, shown as name, bank and account number.
+- **Amount:** defaults to the full available amount. Values above it are blocked on the client.
+- Deposit date, deposit slip no, deposited by, remarks.
+
+**Detail page (`/[id]`)**
+
+- All fields plus the GL journal number.
+- **Cancel** button (gated by `.cancel`) that asks for a reason.
+
+**Cash in hand view (optional tab on the list page)**
+
+- A daily table: Date · Opening · Cash in · Cash out · Deposited · Closing.
+- Uses `/cash-in-hand/daily`.
+
+---
+
+## 9. Integration with the Day-End Sales Report
+
+The report only consumes this module's figures and owns no deposit logic.
+
+**Backend:** `DayEndReportService` calls `ICashInHandService.GetRangeAsync` instead of computing `NetCash` inline.
+
+- `DayEndReportDayDto` gets three new fields: `OpeningCashInHand`, `CashDeposited` and `ClosingCashInHand`. `NetCash` stays.
+- In the totals row, `Opening` comes from the first day and `Closing` from the last day. `CashDeposited` is summed.
+- `DayEndReportDto` (single day) gets `Deposits[]`: `BankDepositId, DocNo, BankAccountName, BankName, AccountNumber, DepositSlipNo, DepositDate, Amount`.
+
+**Page (`/dashboard/sales/day-end-report`)**
+
+- Replace the one-line "Net cash in hand" text with a **Cash** card group:
+  - Opening cash in hand
+  - Net cash today
+  - Deposited to bank
+  - **Remaining cash in hand** (amber when greater than 0)
+- Add a **Bank deposits** table (bank account · slip no · amount), linking to each deposit's detail page.
+- Daily breakdown table: add **Deposited** and **Cash in hand** columns.
+
+**PDF (`lib/pdf/day-end-report-pdf.ts`)**
+
+- **Single day:** add the cash block and the deposits list.
+- **Day-wise:** add the same two columns.
+
+---
+
+## 10. Phases
+
+1. **Cash in hand:** add `CashInHandService` and `BusinessDayClock`, then refactor `DayEndReportService` onto them. There is no behaviour change, so the existing `DayEndReportServiceTests` must stay green.
+2. **Deposits backend:** entity, migration, `BankDepositService`, controller, permissions and nav.
+3. **Deposits frontend:** list, new and detail pages, plus the Accounts hub card.
+4. **Day-end report integration:** §9.
+5. **Verification and docs:** §11, then update `Backend/PROGRESS.md` and `Frontend/PROGRESS.md`.
+
+---
+
+## 11. Verification
+
+**Backend tests (`CashInHandServiceTests`, `BankDepositServiceTests`):**
+
+- Cash slip + card slip + cash invoice payment + card invoice payment + cash expense payment → only the cash items are counted.
+- The opening balance carries across days. A deposit on day 1 lowers day 2's opening.
+- A deposit above the closing balance is rejected.
+- A back-dated deposit that would make a later day negative is rejected.
+- Cancelling restores the cash in hand. Cancelled deposits are ignored everywhere.
+- A Bank account as "from", or a Cash account as "to", is rejected.
+- A branch user cannot see or deposit another branch's cash.
+- A late-evening sale at the timezone boundary lands on the right business day.
+- A GL failure leaves no deposit row behind.
+
+**Manual checks:**
+
+- The deposit form's available amount equals the day-end report's remaining cash for the same day and branch.
+- In GL, the cash account goes down and the bank account goes up by the deposit amount.
+
+---
+
+## 12. Open decisions
+
+| # | Question | Recommended default |
+|---|---|---|
+| 1 | **Which day a deposit counts against.** Monday's cash is deposited on Tuesday morning: should it reduce Monday's or Tuesday's cash in hand? | Monday's (`BusinessDate`). `DepositDate` is kept for GL and bank reconciliation. |
+| 2 | **Over-deposit.** Block deposits above cash in hand, or only warn? | Block. Till surplus/shortage should be a separate "cash over/short" entry later. |
+| 3 | **Starting point / float.** From when is cash counted, and does each till keep a fixed float? | `CashTrackingStartDate`. Add an optional per-branch opening float later if tills keep one. |
+| 4 | **Source of truth.** Cash in hand is derived from sales and expense documents (per branch), not from the GL cash account balance. GL has no branch dimension. | Use the document-derived figure. The GL balance can be shown later as a cross-check. |
+| 5 | **Several deposits per day.** Allow mid-day pickups? | Yes, any number, as long as the total stays within cash in hand. |
diff --git a/docs/DAY_END_SALES_REPORT_PLAN.md b/docs/DAY_END_SALES_REPORT_PLAN.md
new file mode 100644
index 0000000..dbc7db4
--- /dev/null
+++ b/docs/DAY_END_SALES_REPORT_PLAN.md
@@ -0,0 +1,191 @@
+# Day-End Sales Report — Implementation Plan
+
+A per-day view of sales, collections (cash vs card), expenses and resulting income, with a
+day-wise income chart and a PDF export.
+
+> **Naming:** `SalesDayEnd` already exists — it is the cashier close-out (shown in the sidebar
+> as "Approved Invoices", permission code `sales.day-end`). This module is a separate,
+> read-only report: **Day-End Sales Report**, code `sales.day-end-report`.
+
+---
+
+## 1. Requirements
+
+For a selected day (and branch):
+
+| Group | Figures |
+|---|---|
+| Sales | Total sales, Paid amount, Due amount |
+| Payment split | Paid by cash, Paid by card |
+| Counts | Sales count, Sales count by cash, Sales count by card |
+| Expenses | Expenses of the day (total + list) |
+| Result | Income of the day |
+
+Plus:
+
+- Day-wise income chart over a date range.
+- Day-wise income exported as a PDF.
+
+---
+
+## 2. Current state
+
+| Area | What exists | Gap |
+|---|---|---|
+| Sales documents | `SalesSlip`, `BundleSale`, `SalesInvoice` — slips and invoices carry `GrandTotal` / `PaidAmount` / `BalanceAmount` | — |
+| Payment method | `SalesSlip` has only `PaidAmount`; `SalesInvoicePayment` stores only the GL bank/cash account | **No cash/card information is recorded on any sale** |
+| Expenses | `Expense` (`ExpenseDate`, `Amount`, `Status`) and `ExpensePayment` (`PaymentMethod`) | — |
+| Charts | `chart.js` + `react-chartjs-2` (`components/ui/line-chart.tsx`, `bar-chart.tsx`, `pie-chart.tsx`) | — |
+| PDF | `jspdf` (used by `components/invoice-template/InvoicePrintKit.tsx`), `lib/simple-pdf.ts` | No PDF library on the backend → generate in the browser |
+| Dates | Slip/invoice dates are stored in UTC; existing day-end groups by UTC date | Late-evening local sales fall on the wrong day |
+
+---
+
+## 3. Phase 1 — Capture payment method on sales (prerequisite)
+
+1. Add enum `Domain/Enums/SalesPaymentMethod.cs`: `Cash`, `Card`, `BankTransfer`, `Cheque`
+   (mirrors `ExpensePaymentMethod`).
+2. **`SalesSlip` and `BundleSale`:** add `CashAmount` and `CardAmount`
+   (invariant: `CashAmount + CardAmount = PaidAmount`). The sale's method is derived:
+   - **Cash** — `CardAmount = 0`
+   - **Card** — `CashAmount = 0`
+   - **Mixed** — both > 0
+3. **`SalesInvoicePayment`:** add `PaymentMethod` (also on the pay request DTO).
+4. **Services:** validate the split in `SalesSlipService`, `BundleSaleService`,
+   `SalesInvoicePaymentService`.
+5. **UI:**
+   - POS slip form and bundle sale form: Cash / Card amount inputs.
+   - Invoice payment dialog: method dropdown.
+6. **Migration:**
+   - Add the columns.
+   - Backfill slips and bundles with `CashAmount = PaidAmount`, `CardAmount = 0` (the code
+     comments note that every sale was treated as cash before partial payments).
+   - Backfill invoice payments as `Cash`.
+
+---
+
+## 4. Phase 2 — Backend report
+
+**New files**
+
+- `Dtos/Reports/DayEndReportDtos.cs`
+- `Services/DayEndReportService.cs`, `Services/Interfaces/IDayEndReportService.cs`
+- `Controllers/DayEndReportController.cs`
+
+### 4.1 `GET /day-end-report?date=YYYY-MM-DD&branchId=`
+
+Returns one day:
+
+| Section | Fields |
+|---|---|
+| Sales | `TotalSales`, `PaidAmount`, `DueAmount` |
+| Payment split | `PaidByCash`, `PaidByCard`, `PaidByOther` |
+| Counts | `SalesCount`, `CashSalesCount`, `CardSalesCount`, `MixedSalesCount` |
+| Returns | `SalesReturns` |
+| Expenses | `ExpenseTotal`, `Expenses[]` (doc no, category, title, payee, amount) |
+| Income | `Income = TotalSales − SalesReturns − ExpenseTotal` |
+| Optional | `NetCash = cash collected − expense payments made in cash` (till check) |
+
+Sources:
+
+- **Sales:** Posted slips, bundles and invoices dated that day. Use `GroupBy` with `Sum`/`Count`
+  in the database, not in memory.
+- **Returns:** `SalesReturn` dated that day.
+- **Expenses:** Posted `Expense` rows with `ExpenseDate` = that day. Cancelled ones are excluded.
+
+### 4.2 `GET /day-end-report/daily?from=&to=&branchId=`
+
+One row per day: `Date, TotalSales, Paid, Due, Cash, Card, Expenses, Income`, plus a totals row.
+
+- Days with no activity are filled in as zeros.
+- The range is capped at about 92 days.
+- This endpoint feeds both the chart and the PDF.
+
+### 4.3 Cross-cutting
+
+- **Branch scope:** invoices use `BranchId`. Slips and bundles are filtered through their
+  warehouse. Reuse `BranchAccessService`.
+- **Business timezone:** add a setting in `appsettings.json` (next to `SalesDayEnd`). Convert
+  the local day to a UTC `[start, end)` range before querying.
+- **Permissions and nav:**
+  - Seed a `sales.day-end-report` view permission and grant it through a migration (same
+    pattern as `GrantExpensePermissions`).
+  - Add a nav entry in `SubNavItemConfiguration`.
+- **Wiring:**
+  - Register the service in `Program.cs`.
+  - Add new error codes (e.g. invalid range) to `System/Errors/ErrorCodes.cs`.
+
+---
+
+## 5. Phase 3 — Frontend page `/dashboard/sales/day-end-report`
+
+- **API and types:** `lib/api/day-end-report.ts`, with types added to `types/sales.ts`.
+- **Toolbar:** date picker (defaults to today), branch selector, **Download PDF** button.
+- **Summary cards:**
+  - Total Sales · Paid · Due
+  - Paid by Cash · Paid by Card
+  - Sales count · Cash count · Card count
+  - Expenses
+  - **Income**, emphasised, green or red by sign
+- **Expenses table** for the selected day.
+- **Day-wise income chart:**
+  - From/to picker, defaulting to the last 30 days.
+  - Income line (`line-chart.tsx`), with Sales and Expenses alongside it.
+  - A daily breakdown table below the chart.
+- **Sidebar:** add the entry to `components/Layouts/AppSidebar.tsx`, gated by the
+  `sales.day-end-report` permission.
+
+---
+
+## 6. Phase 4 — PDF export (day-wise income)
+
+- **Where:** new `lib/pdf/day-end-report-pdf.ts`, using `jspdf` and `jspdf-autotable` (new,
+  small dependency).
+- **Page 1:**
+  - Company and branch header, date range, when it was generated.
+  - Totals for the period.
+  - The chart image (`chart.toBase64Image()` from the Chart.js instance).
+- **Following pages:** daily table (Date · Sales · Paid · Due · Cash · Card · Expenses · Income)
+  with a totals row.
+- **Single-day variant:** the same module also exports one day (summary cards + expense list).
+
+---
+
+## 7. Phase 5 — Verification
+
+- **Backend tests** for the aggregates:
+  - A mix of slips, bundles and invoices.
+  - Partial payments.
+  - Split cash/card payments.
+  - A cancelled expense, which must be excluded.
+  - A late-evening sale at the timezone boundary.
+- **Frontend checks:**
+  - Card totals match the daily table.
+  - Days with no activity show as zero.
+  - The PDF paginates correctly over long ranges.
+- Update `Backend/PROGRESS.md` and `Frontend/PROGRESS.md`.
+
+---
+
+## 8. Open decisions
+
+| # | Question | Recommended default |
+|---|---|---|
+| 1 | **Income basis.** Accrual (sales − returns − expenses dated that day) or cash basis (money collected that day − expenses paid that day, including installments on older invoices)? | Accrual. `NetCash` is shown as a secondary figure. |
+| 2 | **Split tender.** Can one sale be paid partly by cash and partly by card? | Yes (`CashAmount`/`CardAmount`). If not, use a single `PaymentMethod` and drop the Mixed count. |
+| 3 | **Scope.** Include all of slips, bundles and invoices, or only POS (slips and bundles)? | All three. |
+
+Phase 1 must ship first. Without it there is no reliable cash/card data to report on.
+
+**Implemented 2026-10-08 with the recommended defaults.** Changes from the plan made during the build
+(details in `Backend/PROGRESS.md` and `Frontend/PROGRESS.md`):
+
+- Sales returns are **not** subtracted from income: `SalesReturnLine` has no price, so a return can't be valued.
+- The UI only creates invoices, so the cash/card split comes from a **payment method on each invoice payment**
+  (it defaults from the account: a Cash account means Cash, a Bank account means Card). Slip/bundle `CashAmount`/`CardAmount` exist for API callers.
+- Sale counts also include **Other** (bank transfer/cheque) and **Unpaid**, so the counts add up to the total.
+- Rows are grouped by local day in memory over slim database projections, not with SQL `GroupBy`.
+- PDF tables are drawn with plain `jspdf`. `jspdf-autotable` was not added.
+
+**Bank deposits (2026-10-08):** the report's cash figures (net cash, opening/closing cash in hand, deposits) now come
+from the Bank Deposit module's `ICashInHandService` — see `docs/BANK_DEPOSIT_MODULE_PLAN.md` §9.
diff --git a/docs/DUAL_APPROVAL_PLAN.md b/docs/DUAL_APPROVAL_PLAN.md
new file mode 100644
index 0000000..40cdcaf
--- /dev/null
+++ b/docs/DUAL_APPROVAL_PLAN.md
@@ -0,0 +1,297 @@
+# Dual Approval Plan — Stock Adjustments & Price Adjustments
+
+> **Status:** implemented 2026-10-12 with the §8 recommended defaults (counts go through approval; initial prices on
+> a new item need none; no Admin bypass; thresholds configurable, default "always two"; selling prices only; no future
+> effective dates; no auto-expiry). Deviations: the approval doc type for price adjustments is `PADJ` (not `PRICE`);
+> count-variance serial moves are recorded against the adjustment rather than the count; the Approvals inbox is open
+> to every signed-in user (it lists only what they may approve and their own requests). Details in
+> `Backend/PROGRESS.md` and `Frontend/PROGRESS.md`.
+> **Goal:** a stock adjustment or a selling-price change only takes effect after **two different people**
+> (neither of them the person who requested it) have approved it.
+> **Reference to mirror:** `PurchaseOrderService` — `PendingApproval` → `Approved`/`Rejected`, the
+> `Approve` action permission, and the "you cannot approve your own document" rule. This plan extends that
+> one-step approval to two steps and puts it in one shared place so both documents use the same rules.
+
+---
+
+## 1. Requirements
+
+| # | Requirement |
+|---|---|
+| 1 | A stock adjustment (including wastage) changes stock and posts to GL **only after the second approval**. |
+| 2 | A selling-price change (min / max / flat price) is applied to the item **only after the second approval**. |
+| 3 | Maker–checker: the requester can't approve. Approver 1 and approver 2 must be **different people**. |
+| 4 | Either approver can **reject** with a reason. A rejected request never takes effect. |
+| 5 | Everyone involved is notified: approvers when something is waiting for them, the requester when it is approved or rejected. |
+| 6 | A full audit trail: who requested, who approved at each level, when, and any comments. |
+| 7 | An **Approvals** inbox listing everything waiting for the current user. |
+
+---
+
+## 2. Current state
+
+| Area | What exists | Gap |
+|---|---|---|
+| Stock adjustments | `AdjustmentService.CreateAsync` **posts immediately**: it moves stock, posts GL and writes the ledger in one transaction. `AdjustmentStatus` already has `Draft`, `PendingApproval` and `Posted`, but only `Posted` is ever used. | No approval step at all. |
+| Wastage | `/stock/wastage` records adjustments with wastage reason codes through the same path. | Same: posts immediately. |
+| Stock counts | `CountService.PostAsync` creates a variance `StockAdjustment` and posts it immediately. | A count is effectively an adjustment, so it bypasses any approval added to adjustments (see §8, decision 3). |
+| Selling prices | `Item.SellingMinPrice / SellingMaxPrice / SellingFlatPrice` are edited directly in the item Edit dialog and saved instantly. `SalesPricingService` reads them. | No price-change document, no history, no approval. |
+| Approval pattern | Purchase orders: one approver, Admin only, not your own PO. `RolePermissionAction.Approve` exists and `NavPolicies.ApproveAction` is used on PO endpoints. | Only one level, and it's built into the PO service. |
+| Notifications | `INotificationService.RaiseAsync` broadcasts to all active users (in-app only). | No way to notify only approvers or only the requester. |
+
+---
+
+## 3. Design overview
+
+```
+Requester ──create──► PendingApproval (level 1)
+                          │ approve (user A ≠ requester)
+                          ▼
+                     PendingSecondApproval (level 2)
+                          │ approve (user B ≠ requester, ≠ A)
+                          ▼
+                     Approved → effect applied in the same transaction
+                     (stock posted + GL / prices written + history)
+
+Reject at either level ──► Rejected (terminal; nothing applied)
+Requester may Withdraw while still pending ──► Cancelled
+```
+
+- **One shared approval engine** (`ApprovalService`) holds the rules: who may approve, the two-person rule,
+  and the audit rows. The two document services call it, and only apply their effect when it says
+  "fully approved".
+- **Nothing changes stock or prices until the final approval.** Pending documents are only requests.
+- **Re-check at final approval.** Stock may have moved since the request. A decrease that would now make
+  stock negative fails at approval time with a clear message, and the document stays pending.
+
+---
+
+## 4. Shared approval engine
+
+### 4.1 Entity `DocumentApproval` (table `document_approvals`)
+
+One row per decision, so the full trail is kept.
+
+| Field | Notes |
+|---|---|
+| `DocumentApprovalId` | PK |
+| `DocType` | `ADJ` (stock adjustment) or `PRICE` (price adjustment) |
+| `DocId` | the document's id |
+| `Level` | 1 or 2 |
+| `Decision` | `Approved` / `Rejected` |
+| `DecidedBy`, `DecidedAt` | the user and time |
+| `Comment` | optional; required when rejecting |
+
+### 4.2 `IApprovalService`
+
+```csharp
+// Validates the caller may decide at the document's current level, records the row,
+// and returns where the document stands now.
+Task<ApprovalOutcome> DecideAsync(string docType, int docId, int requestedBy, int currentLevel,
+    bool approve, string? comment, CancellationToken ct);
+// ApprovalOutcome: NextLevel(2) | FullyApproved | Rejected
+
+Task<IReadOnlyList<ApprovalStepDto>> HistoryAsync(string docType, int docId, CancellationToken ct);
+```
+
+**Rules enforced in one place:**
+1. The caller has the `Approve` action on the document's nav code (`stock.adjustments` or `products.price-adjustments`).
+2. The caller is not the requester (`ApprovalForbidden`, 403).
+3. At level 2, the caller is not the level-1 approver (`ApprovalSamePerson`, 403).
+4. The document is at the expected level (`ApprovalNotPending`, 409). This also stops two people approving the same level at once (row-version check).
+5. **Optional, per settings (§7):** level 2 is limited to particular roles (for example, Manager or Admin).
+
+**Admin bypass:** none. Even an Admin can't approve their own request or both levels (see §8, decision 5).
+
+---
+
+## 5. Stock adjustments
+
+### 5.1 Status flow
+
+`AdjustmentStatus` becomes: `Draft`, `PendingApproval`, `PendingSecondApproval`, `Posted`, `Rejected`, `Cancelled`.
+Existing rows stay `Posted`.
+
+### 5.2 Changes to `StockAdjustment`
+
+- Add `RequestedBy` (the existing `CreatedBy`), `ApprovedLevel1By/At`, `ApprovedLevel2By/At`, `RejectedBy/At`, `RejectReason`.
+- Add `PostedAt`. Today the ledger and GL use the creation time; they will use the **posting time**.
+- **Inbound serials:** today, new serials are created at once from `SerialNos`. While a request is pending, the
+  typed serial numbers are stored on the line (new `StockAdjustmentLineSerialNo` rows or a JSON column) and the
+  serial records are created only when it posts.
+- **Outbound serials** are validated when the request is made and **re-validated at posting**. A serial sold in the
+  meantime fails the approval with a message naming that serial.
+
+### 5.3 `AdjustmentService`
+
+| Method | Behaviour |
+|---|---|
+| `CreateAsync` | Validates as today (reason code, items, serials), saves the header and lines as `PendingApproval`. **No** stock movement and no GL. Notifies approvers. |
+| `ApproveAsync(id, comment)` | `ApprovalService.DecideAsync`. On level 1: status becomes `PendingSecondApproval` and level-2 approvers are notified. On full approval: in one transaction, run today's posting code (`IStockMutator.ApplyAsync`, serial moves, `PostAdjustmentJournalAsync`), then set `Posted` and notify the requester. If posting fails (for example, negative stock), nothing is saved and the status stays `PendingSecondApproval`. |
+| `RejectAsync(id, reason)` | Records the rejection, sets `Rejected` and notifies the requester. |
+| `CancelAsync(id)` | Requester only, while pending: sets `Cancelled`. |
+
+The posting code moves into a private `PostAsync(StockAdjustment)` so that create, approve and stock counts
+(§8, decision 3) all share it.
+
+### 5.4 API (`/api/v1/stock-adjustments`)
+
+| Method | Route | Permission |
+|---|---|---|
+| POST | `/` | `stock.adjustments` with `Create` (now creates a **request**) |
+| POST | `/{id}/approve` | `stock.adjustments` with `Approve` |
+| POST | `/{id}/reject` | `stock.adjustments` with `Approve` |
+| POST | `/{id}/cancel` | `stock.adjustments` (requester only, checked in the service) |
+| GET | `/{id}` | now also returns the approval history and pending level |
+| GET | `/` | new `status` filter |
+
+---
+
+## 6. Price adjustments (new document)
+
+### 6.1 Entities
+
+**`PriceAdjustment`** (`price_adjustments`): `PriceAdjustmentId`, `DocNo` (`PADJ-…`), `Reason`, `EffectiveDate`
+(defaults to the approval date), `Status` (same flow as §5.1), the requested/approved/rejected stamps, `RowVersion`.
+
+**`PriceAdjustmentLine`**: `ItemId`, plus the **old** values (snapshot when the request is made) and the **new** values for
+`SellingMinPrice`, `SellingMaxPrice` and `SellingFlatPrice`.
+
+**`ItemPriceHistory`** (`item_price_history`): one row per applied change. It holds the item, old and new values,
+the `PriceAdjustmentId`, the date applied, and both approvers. This answers "what was the price on day X, and who
+approved it?"
+
+### 6.2 Rules
+
+- **Validation when the request is made:** each item exists and is active; min ≤ flat ≤ max where given; at least one value differs from the current price.
+- **One pending request per item:** a second pending request for the same item is rejected (`PriceAdjustmentItemPending`), so two requests can't overwrite each other.
+- **At final approval, in one transaction:**
+  - If an item's current price no longer matches the request's "old" snapshot (someone changed it in between), that approval fails with `PriceAdjustmentStale`, and the requester raises a new request.
+  - Otherwise, write the new prices to `Item` and add an `ItemPriceHistory` row.
+- **Effective date in the future (optional, §8 decision 6):** the request is approved but applied by a daily job on that date.
+
+### 6.3 Closing the direct-edit route
+
+Selling prices in the item **Edit dialog** become read-only, with a "Request price change" button that opens the
+price-adjustment form pre-filled for that item. On the backend, `ItemService.UpdateAsync` stops changing price
+fields: it rejects a change with `PriceChangeRequiresApproval`, or ignores the price fields (see §8, decision 4).
+Prices set when an item is **first created** do not need approval (§8, decision 4).
+
+### 6.4 API (`/api/v1/price-adjustments`)
+
+List, get (with history), create, approve, reject and cancel, using the same permission pattern as §5.4 on a
+new nav code `products.price-adjustments`.
+
+There is also `GET /api/v1/items/{id}/price-history`.
+
+---
+
+## 7. Approval settings
+
+A singleton `ApprovalConfig`, edited under **Settings → Approvals**:
+
+| Setting | Default | Purpose |
+|---|---|---|
+| `StockAdjustment.Levels` | 2 | 0 = post immediately (today's behaviour), 1 = single approval, 2 = dual approval |
+| `StockAdjustment.Level2ThresholdValue` | 0 | Adjustments whose absolute stock value is below this need only one approval (0 = always two) |
+| `PriceAdjustment.Levels` | 2 | as above |
+| `PriceAdjustment.Level2ThresholdPercent` | 0 | Changes smaller than this % need only one approval (0 = always two) |
+| `Level2Roles` | empty | When set, only these roles can give the second approval |
+
+---
+
+## 8. Open decisions
+
+| # | Question | Recommended default |
+|---|---|---|
+| 1 | **Who can approve:** anyone with the `Approve` action on the screen, or fixed roles? | Anyone with `Approve`, with `Level2Roles` (§7) available to restrict level 2 to managers. |
+| 2 | **Thresholds:** dual approval for every adjustment, or only above a value? | Always two by default; thresholds configurable (§7). |
+| 3 | **Stock counts:** should posting a count also go through dual approval? It creates an adjustment. | Yes. A count post creates its variance adjustment as `PendingApproval`, otherwise counts become a way around approval. |
+| 4 | **Item edit and item creation:** block price edits in the Edit dialog? Do initial prices on a new item need approval? | Block in the Edit dialog (use "Request price change"). Initial prices on creation don't need approval. |
+| 5 | **Admin bypass:** can an Admin approve their own request, or both levels? | No. The two-person rule applies to everyone. |
+| 6 | **Future effective dates** for price changes? | Not in v1. A change applies when it is approved. |
+| 7 | **Price adjustment scope:** selling prices only, or also stock cost (inventory revaluation)? | Selling prices only. Cost revaluation touches FIFO layers and GL and should be its own document. |
+| 8 | **Expiry:** should a request still pending after N days be cancelled automatically? | No auto-expiry. The Approvals inbox shows its age. |
+
+---
+
+## 9. Notifications
+
+`INotificationService` gets a targeted method next to the broadcast one:
+
+```csharp
+Task NotifyUsersAsync(IEnumerable<int> userIds, string moduleKey, string title, string message, string? entityType, int? entityId, CancellationToken ct);
+```
+
+New modules (in-app on by default, through a seed migration like `EnableLowStockAlerts`):
+
+| Key | Sent to |
+|---|---|
+| `approval.pending` | users who can approve at the document's current level (excluding the requester and the level-1 approver) |
+| `approval.approved` | the requester, when fully approved |
+| `approval.rejected` | the requester, with the reason |
+
+---
+
+## 10. Frontend
+
+- **Approvals inbox** (`/dashboard/approvals`, a sidebar badge with the count):
+  - Lists pending stock and price adjustments waiting for **me**, with their age, level (1/2) and requester.
+  - Approve / Reject (reject asks for a reason).
+- **Stock → Adjustments:** status badges (Pending 1/2, Posted, Rejected, Cancelled); the detail page shows the approval timeline and Approve / Reject / Cancel buttons by role. The New form's button reads "Submit for approval".
+- **Wastage:** the same status badges; recorded wastage shows "Pending approval" until posted.
+- **Products → Price Adjustments** (new):
+  - The list.
+  - The **new** form: pick items, see current prices, enter new prices, reason.
+  - The detail page with the timeline.
+- **Item page:** the prices in the Edit dialog are read-only, with "Request price change"; a new "Price history" panel.
+- **Settings → Approvals:** the §7 settings.
+
+---
+
+## 11. Migration & rollout
+
+- **Migration `AddDualApproval`:**
+  - Creates the `document_approvals`, `price_adjustments`, `price_adjustment_lines`, `item_price_history` and `approval_config` tables.
+  - Adds the new columns on `stock_adjustments`.
+  - Seeds the nav item and permission for `products.price-adjustments` and the notification modules.
+- **Existing adjustments** stay `Posted`, with no approval rows.
+- **Roll-out safety:** ship with `Levels` defaulting to 2, but tell admins to grant the `Approve` action to at least
+  **two** users per branch before deploying. Otherwise nothing can ever be approved.
+
+---
+
+## 12. Phases
+
+1. **Approval engine:** `DocumentApproval`, `ApprovalService`, targeted notifications, `ApprovalConfig`.
+2. **Stock adjustments:** status flow, deferred posting (including inbound serials), approve/reject/cancel endpoints; wastage and counts on the same path.
+3. **Price adjustments:** entities, service, endpoints, price history, item-edit lock.
+4. **Frontend:** Approvals inbox, adjustment/wastage updates, Price Adjustments pages, Settings → Approvals.
+5. **Tests and docs** (§13), plus `PROGRESS.md` updates.
+
+---
+
+## 13. Verification
+
+**Backend tests:**
+
+- **Approval engine:**
+  - The requester can't approve.
+  - The same person can't approve both levels.
+  - A user without `Approve` is refused.
+  - Approving the wrong level is refused.
+  - A rejection needs a reason.
+- **Stock adjustments:**
+  - Nothing moves until the second approval.
+  - After full approval, the ledger, GL and serials match today's immediate posting.
+  - An approval that would make stock negative fails and the adjustment stays pending.
+  - A rejected adjustment never posts.
+  - The value threshold drops it to one level.
+- **Price adjustments:**
+  - Prices change only after the second approval, and a history row is written.
+  - The stale-price check works.
+  - A second pending request for the same item is refused.
+  - The item edit can no longer change prices.
+- **Counts:** posting a count creates a pending adjustment, not a posted one.
+
+**Manual checks:** a full two-user approval in the UI for each document, the notification for each step, and the Approvals inbox count.
diff --git a/docs/EXPENSE_MODULE_PLAN.md b/docs/EXPENSE_MODULE_PLAN.md
new file mode 100644
index 0000000..7677e18
--- /dev/null
+++ b/docs/EXPENSE_MODULE_PLAN.md
@@ -0,0 +1,299 @@
+# Expense Module Plan
+
+> **Status:** implemented 2026-10-07 (phases 1–5) using the §10 defaults. Deviations from this plan are listed in
+> §11 and in `Backend/PROGRESS.md` / `Frontend/PROGRESS.md`. Not yet verified against a live GL service.
+> **Lives under:** the existing **Accounts** nav item (`NavItemId = 12`, `/dashboard/accounts`).
+> **GL transport:** `docs/12-GENERAL-LEDGER-INTEGRATION.md` (typed calls via `IGeneralLedgerService`).
+> **Reference implementation to mirror:** `PurchaseInvoicePaymentService` (call GL before commit, so a
+> failed post rolls back the whole operation).
+
+---
+
+## 1. Goal
+
+Record day-to-day business expenses that don't come through procurement (electricity bill, rent,
+salaries paid outside payroll, stationery, …). Users can:
+
+- pick a **category** (Utility, Rental, Salaries, Other),
+- pick a **title** under it (Utility → Electricity, Water, …),
+- enter the **amount**, date, payee and bill reference,
+- **pay** it now or later (in one or more installments) from a GL cash/bank account,
+- see the **payment status** (Unpaid / Partially Paid / Paid).
+
+Every posted expense and every payment creates a real GL journal entry, so the P&L shows it.
+
+---
+
+## 2. Concepts
+
+```
+ExpenseCategory  (Utility, Rental, Salaries, Other)   ← seeded, admins can add more
+   └── ExpenseTitle  (Electricity, Water, …)          ← seeded, admins can add more
+          └── default GL expense account code
+
+Expense          (one bill: category + title + amount + status)
+   └── ExpensePayment  (0..n installments, each posts a GL entry)
+```
+
+### 2.1 Seeded categories and titles
+
+| Category | Seeded titles |
+|---|---|
+| **Utility** | Electricity, Water, Telephone, Internet, Gas |
+| **Rental** | Building Rent, Vehicle Rent, Equipment Rent |
+| **Salaries** | Staff Salaries, Wages, Overtime, Bonus, EPF / ETF Contribution |
+| **Other** | Stationery, Transport, Repairs & Maintenance, Cleaning, Miscellaneous |
+
+- Seeded rows have `IsSystem = true`. They **cannot be deleted or renamed**, only deactivated.
+- Users with the `accounts.expense-setup` permission can add **custom titles** under any category,
+  and **custom categories**.
+- Every title has a **GL expense account code**. Seeded titles default to the codes in
+  `appsettings.json` (§5). Users can override the code per title.
+
+---
+
+## 3. Data model (backend)
+
+All new entities go in `Domain/Entities/`, with configurations in `Infra/Persistence/Configurations/`
+and one EF migration.
+
+### 3.1 `ExpenseCategory`
+
+| Field | Type | Notes |
+|---|---|---|
+| ExpenseCategoryId | int PK | |
+| Code | string(30), unique | `UTILITY`, `RENTAL`, `SALARIES`, `OTHER`, or user-defined |
+| Name | string(100), unique | |
+| IsSystem | bool | seeded = true |
+| IsActive | bool | |
+| SortOrder | int | |
+| CreatedBy / CreatedAt / UpdatedBy / UpdatedAt | | standard audit columns |
+
+### 3.2 `ExpenseTitle`
+
+| Field | Type | Notes |
+|---|---|---|
+| ExpenseTitleId | int PK | |
+| ExpenseCategoryId | int FK | |
+| Name | string(100) | unique **within** the category |
+| GlExpenseAccountCode | string(20) | the account debited when an expense with this title is posted |
+| IsSystem | bool | |
+| IsActive | bool | |
+| SortOrder | int | |
+| audit columns | | |
+
+### 3.3 `Expense` (header)
+
+| Field | Type | Notes |
+|---|---|---|
+| ExpenseId | int PK | |
+| DocNo | string | `EXP-{branch}-{yyyy}-{seq}` via `NumberSequenceService` (DocType `EXPENSE`) |
+| BranchId | int FK | branch-scoped like other documents (`BRANCH_ISOLATION_PLAN.md`) |
+| ExpenseDate | DateOnly | the bill date, which is also the GL entry date on posting |
+| DueDate | DateOnly? | optional, used for "overdue" in the list |
+| ExpenseCategoryId | int FK | |
+| ExpenseTitleId | int FK | must belong to the chosen category |
+| Payee | string(150)? | free text (e.g. "CEB", "Landlord – Mr. Silva") |
+| VendorId | int? FK | optional link to an existing vendor |
+| BillReference | string(50)? | the supplier's bill/account number |
+| Description | string(500)? | |
+| Amount | decimal(18,2) | > 0 |
+| PaidAmount | decimal(18,2) | maintained by payments |
+| BalanceAmount | decimal(18,2) | `Amount - PaidAmount` |
+| Status | enum `ExpenseStatus` | `Draft`, `Posted`, `Cancelled` |
+| PaymentStatus | enum `ExpensePaymentStatus` | `Unpaid`, `PartiallyPaid`, `Paid`, derived from Paid/Balance |
+| GlExpenseAccountCode | string(20) | **snapshot** of the title's code at posting time |
+| GlJournalNo | string? | the accrual journal entry |
+| PeriodMonth | string(7)? | optional "covers" period, e.g. `2026-09` for September's electricity |
+| RowVersion | uint | ETag concurrency, same as `PurchaseInvoice` |
+| audit columns | | |
+
+### 3.4 `ExpensePayment`
+
+Mirrors `PurchaseInvoicePayment` field for field:
+
+| Field | Type | Notes |
+|---|---|---|
+| ExpensePaymentId | int PK | |
+| ExpenseId | int FK | |
+| Amount | decimal(18,2) | ≤ Expense.BalanceAmount |
+| PaymentDate | DateTime | same `ResolvePaymentDate` rule (no future dates, one day of slack) |
+| PaymentMethod | enum | `Cash`, `BankTransfer`, `Cheque`, `Card` |
+| GlBankAccountId | long | account from `IGeneralLedgerService.ListBankAccountsAsync` |
+| BankAccountName | string | snapshot |
+| ChequeNo | string? | required when method = Cheque |
+| Reference | string? | |
+| GlJournalNo | string? | |
+| CreatedBy / CreatedAt | | |
+
+### 3.5 Enums (`Domain/Enums/`)
+
+`ExpenseStatus { Draft, Posted, Cancelled }`
+`ExpensePaymentStatus { Unpaid, PartiallyPaid, Paid }`
+`ExpensePaymentMethod { Cash, BankTransfer, Cheque, Card }`
+
+---
+
+## 4. Workflow and GL postings
+
+```
+ Draft ──Post──► Posted (Unpaid) ──Pay──► Partially Paid ──Pay──► Paid
+   │                │
+   └──Delete        └──Cancel (only if PaidAmount = 0) ──► Cancelled
+```
+
+| Action | Rule | GL entry |
+|---|---|---|
+| **Create (Draft)** | Editable, no GL impact | — |
+| **Post** | Draft only. Snapshots the title's GL code. | **Dr** title's expense account / **Cr** Accrued Expenses (`Expense:GlAccruedExpensesCode`) |
+| **Pay** | Posted and Balance > 0, installments allowed | **Dr** Accrued Expenses / **Cr** selected cash/bank account |
+| **Post & Pay** (one click, the common "paid in cash right now" case) | Draft. Runs Post and a full Pay in **one transaction**. | Both entries above |
+| **Cancel** | Posted with no payments | Reversing entry: **Dr** Accrued / **Cr** expense account |
+| **Delete** | Draft only | — |
+
+All GL calls happen inside `_uow.ExecuteInTransactionAsync` **before** the local rows are saved,
+the same pattern as `PurchaseInvoicePaymentService`. If GL is down or rejects the entry, nothing is saved.
+`SourceModule = "EXPENSE"` / `"EXPENSE_PAYMENT"`, `Reference = DocNo`.
+
+**Why accrue then pay** (rather than Dr Expense / Cr Bank on payment): unpaid bills still show
+in the P&L for the month they belong to, and the Accrued Expenses balance equals the total unpaid bills.
+"Post & Pay" keeps the one-step case fast.
+
+---
+
+## 5. Configuration (`appsettings.json`)
+
+```json
+"Expense": {
+  "GlAccruedExpensesCode": "2300",
+  "DefaultGlAccountCodes": {
+    "UTILITY":  "6100",
+    "RENTAL":   "6200",
+    "SALARIES": "6300",
+    "OTHER":    "6900"
+  }
+}
+```
+
+Seeded titles take their category's default code. The actual codes must match the GL service's chart
+of accounts. **Confirm them with the GL owner before seeding** (open question Q3).
+
+---
+
+## 6. API (`Controllers/ExpensesController.cs`, `ExpenseSetupController.cs`)
+
+Policy: `NavPolicies.Prefix + "accounts"`, same door as the cheque/bank screens.
+
+### Setup (categories and titles)
+
+| Method | Route | Purpose |
+|---|---|---|
+| GET | `/api/v1/expense-categories?includeInactive=` | list categories, each with its titles |
+| POST | `/api/v1/expense-categories` | add a custom category |
+| PUT | `/api/v1/expense-categories/{id}` | rename (non-system only) / toggle active |
+| POST | `/api/v1/expense-categories/{id}/titles` | add a custom title |
+| PUT | `/api/v1/expense-titles/{id}` | rename (non-system only) / change GL code / toggle active |
+
+### Expenses
+
+| Method | Route | Purpose |
+|---|---|---|
+| GET | `/api/v1/expenses` | paged list. Filters: branch, category, title, status, paymentStatus, date range, search (DocNo/payee/reference) |
+| GET | `/api/v1/expenses/{id}` | detail + payments (ETag header) |
+| POST | `/api/v1/expenses` | create draft |
+| PUT | `/api/v1/expenses/{id}` | update draft (`If-Match`) |
+| DELETE | `/api/v1/expenses/{id}` | delete draft |
+| POST | `/api/v1/expenses/{id}/post` | post (accrue) |
+| POST | `/api/v1/expenses/{id}/post-and-pay` | post + full payment, body = payment request |
+| POST | `/api/v1/expenses/{id}/cancel` | cancel (reason required) |
+| GET | `/api/v1/expenses/{id}/payments` | payment history |
+| POST | `/api/v1/expenses/{id}/payments` | add a payment / installment |
+| GET | `/api/v1/expenses/summary?from=&to=&branchId=` | totals by category → title, plus paid/unpaid totals (for the dashboard cards) |
+
+### New error codes (`System/Errors/ErrorCodes`)
+
+`EXPENSE_NOT_DRAFT`, `EXPENSE_NOT_PAYABLE`, `EXPENSE_PAYMENT_EXCEEDS_BALANCE`,
+`EXPENSE_HAS_PAYMENTS`, `EXPENSE_TITLE_CATEGORY_MISMATCH`, `EXPENSE_TITLE_INACTIVE`,
+`EXPENSE_SYSTEM_ROW_READONLY`, `EXPENSE_BANK_ACCOUNT_NOT_FOUND`, `EXPENSE_CHEQUE_NO_REQUIRED`.
+
+---
+
+## 7. Backend file checklist
+
+| Layer | Files |
+|---|---|
+| Entities | `ExpenseCategory.cs`, `ExpenseTitle.cs`, `Expense.cs`, `ExpensePayment.cs` |
+| Enums | `ExpenseStatus.cs`, `ExpensePaymentStatus.cs`, `ExpensePaymentMethod.cs` |
+| EF config | `ExpenseConfiguration.cs` (all four tables, seed data, indexes, check constraint `Amount > 0`, **MariaDB-safe quoting**, see commit c97a7e9) |
+| DbContext | 4 `DbSet`s in `ErpDbContext.cs` |
+| DTOs | `Dtos/Expense/ExpenseDtos.cs`, `ExpenseSetupDtos.cs` + FluentValidation validators |
+| Services | `ExpenseSetupService`, `ExpenseService`, `ExpensePaymentService` (+ interfaces) |
+| Controllers | `ExpenseSetupController`, `ExpensesController` |
+| Nav / perms | `SubNavItemConfiguration`: `accounts.expenses` (id 23, sort 4) and `accounts.expense-setup` (id 24, sort 5); `PermissionConfiguration` entries |
+| Number seq | DocType `EXPENSE` |
+| Audit | `IAuditService` entries on create/post/pay/cancel |
+| Program.cs | DI registrations |
+| Migration | `AddExpenseModule` |
+
+---
+
+## 8. Frontend (`Frontend/erp-system/app/dashboard/accounts/`)
+
+| Route | Screen |
+|---|---|
+| `expenses/page.tsx` | List: summary cards (This month total · Unpaid · Overdue), filter bar (category, title, status, payment status, dates), table with **payment status badge** (Unpaid red / Partial amber / Paid green) |
+| `expenses/new/page.tsx` | Form: Branch · Date · **Category** dropdown → **Title** dropdown (filtered by category, with an inline "+ Add title" if permitted) · Payee/Vendor · Bill ref · Period · Amount · Description. Buttons: **Save Draft**, **Post**, **Post & Pay** (opens the payment dialog) |
+| `expenses/[id]/page.tsx` | Detail, GL journal no, payment history, **Add Payment** dialog (amount defaults to balance · date · method · cash/bank account from `bankAccountsApi` · cheque no · reference), Cancel |
+| `expense-setup/page.tsx` | Categories as tabs or accordion → titles table (name, GL code, active, system lock icon); add/edit dialogs |
+
+API client: `lib/api/expenses.ts`. Types: `types/expense.ts`. Reuse the payment dialog pattern from the
+purchase-invoice payment screen.
+
+---
+
+## 9. Implementation phases
+
+1. **Setup data**: entities, config, seed, migration, setup API + setup screen.
+2. **Expense CRUD**: draft create/edit/delete, list/detail screens, DocNo sequence.
+3. **GL posting**: Post, Cancel, Post & Pay, config codes.
+4. **Payments**: installments, payment status, cheque method.
+5. **Reporting**: summary endpoint, list cards, export to CSV.
+6. Docs: add `docs/16-BACKEND-EXPENSES.md` (or extend `00-CORE.md` nav), update `Backend/PROGRESS.md` / `Frontend/PROGRESS.md`.
+
+---
+
+## 10. Open questions
+
+| # | Question | Default if not answered |
+|---|---|---|
+| Q1 | One title per expense, or **multiple lines** per expense (e.g. one bill covering electricity + water)? | One title per expense. Lines can be added later without breaking the API. |
+| Q2 | Can users add **new categories**, or only new titles under the four fixed ones? | **Decided 2026-10-08: titles only.** The four categories are fixed; the create-category endpoint and UI were removed. |
+| Q3 | Real GL account codes for Accrued Expenses and each category? | Placeholders in §5 |
+| Q4 | **Salaries vs. HRM Payroll:** payroll runs don't post to GL today. If payroll GL posting is added later, the "Salaries" category could double-count. Should Salaries expenses be blocked or warned once payroll posts? | Allow for now, add a warning note on the Salaries category |
+| Q5 | Tax (VAT) on expenses: capture input tax separately? | Out of scope for phase 1, amount is gross |
+| Q6 | Attachments (scan of the bill)? | Out of scope for phase 1 |
+| Q7 | Approval step before posting (maker/checker)? | No. Post permission is enough. |
+| Q8 | Recurring expenses (monthly rent auto-draft)? | Phase 2 |
+
+---
+
+## 11. As built: deviations from this plan
+
+- **Nav/permission ids:** sub-items 44 (`accounts.expenses`) and 45 (`accounts.expense-setup`), permissions 54/55.
+  Ids 23/24 in §7 were already taken.
+- **Config (§5):** only `Expense:GlAccruedExpensesCode` is in `appsettings.json`. The per-category default codes are
+  seeded directly (`ExpenseConfiguration.cs`), because `HasData` cannot read configuration. Change them per title on
+  the Expense Setup screen.
+- **GL accounts (2026-10-08):** GL generates account codes itself (its `POST /accounts` takes no code), so the
+  planned 6100–6900 codes could never exist. The dev GL now has `2300` Accrued Expenses (liability) and a
+  non-postable `5200` Operating Expenses control account with children `5200-01` Utilities, `5200-02` Rent,
+  `5200-03` Salaries & Wages and `5200-04` Other Expenses. The seed and migration `UpdateExpenseGlCodes` point the
+  seeded titles at those. Another GL instance will generate its own codes, so check them on Expense Setup.
+- **Status columns:** categories and titles use the codebase's `EntityStatus` (Active/Inactive) instead of an `IsActive` bool.
+- **Payments:** one submission can have several lines (cash + bank). It posts **one** GL journal, and each line becomes
+  an `ExpensePayment` row that shares that journal number. `PaymentMethod`, `ChequeNo` and `Reference` apply to the
+  whole submission.
+- **Cancel:** also allowed on a Draft (no GL entry). A Posted expense with no payments gets a reversing entry dated today
+  (`GlReversalJournalNo`). The reason is stored in `CancelReason`.
+- **No FluentValidation:** request validation uses DataAnnotations plus service checks, matching the rest of the API.
+- **Audit:** no explicit `IAuditService` calls. The DbContext's ChangeTracker audit captures every insert and update.
diff --git a/docs/ITEM_TRACKING_PLAN.md b/docs/ITEM_TRACKING_PLAN.md
new file mode 100644
index 0000000..d1c2963
--- /dev/null
+++ b/docs/ITEM_TRACKING_PLAN.md
@@ -0,0 +1,242 @@
+# Item Tracking (Serial / Batch / Expiry / Warranty) — ERP-core Plan
+
+**Status**: Implemented 2026-10-07 on branch `ui-bug-fixers` (uncommitted). Migration
+`20261007054513_AddItemTrackingSerialsWarranty` generated and **not yet applied** — `Program.cs` runs
+`MigrateAsync` on startup, so it applies on the next backend start. See §6 for what was built
+differently from the plan and §7 for what is still open.
+**Origin**: adapted from the distribution system's `item_tracking_plan.md`. That plan does **not** map
+1:1 — ERP-core already has most of its foundation (see §1). This plan covers only the gaps.
+
+| Phase | Title | Status |
+|-------|-------|--------|
+| 0 | Decisions (see §3) | ✅ Recommendations D1–D7 adopted as written |
+| 1 | `Serial` entity hardening (status enum, location, provenance) | ✅ |
+| 2 | GRN serial capture + per-serial FIFO layers | ✅ |
+| 3 | Serial-aware / FEFO stock consumption | ✅ |
+| 4 | Sales documents — batch/serial on invoice lines, mandatory on tracked items | ✅ (bundles: see §7) |
+| 5 | Warranty start at sale (`WarrantyRegistration`) | ✅ |
+| 6 | Returns — sales return restock to batch/serial, purchase return of serials | ✅ |
+| 7 | Transfers, adjustments, counts — serial carry-through | ✅ |
+| 8 | Frontend — GRN serial entry, sale pickers, lookups | ✅ (gaps in §7) |
+| 9 | Reports — serial/warranty lookup, batch expiry, stock by batch | ✅ (expiry notifications: §7) |
+| 10 | Migration + tests | ✅ migration generated · ✅ 15 unit tests · ❌ e2e |
+
+---
+
+## 1. What already exists (do not rebuild)
+
+| Area | Where | Notes |
+|---|---|---|
+| Global toggles | `Domain/Entities/ProductConfig.cs` (`SerialNumbersEnabled`, `BatchListsEnabled`, `WarrantyPeriodsEnabled`, `CustomWarrantyPeriodsEnabled`) | Singleton row, enforced on item writes. Replaces the other plan's `SysConfig` keys. |
+| Per-item mode | `Item.TrackingMode` (`None`/`Batch`/`Serial`), `Item.Warranty`, `Item.WarrantyPeriodMonths` | Mutually exclusive mode — an item is batch **or** serial, never both. Expiry lives on `Batch`, so there is no separate expiry flag. |
+| Warranty periods | `WarrantyPeriod` master + `WarrantyPeriods.AllowedMonths` (3/6/12/18) | Months, not days. Validated in `ItemService.ValidateWarrantyPeriod`. |
+| Batches | `Batch` (`BatchNo`, `ExpiryDate`, `Barcode`), unique `(ItemId, BatchNo)` | Created/reused at GRN by `GrnService.ResolveBatchAsync`. |
+| Serials | `Serial` (`SerialNo`, `Status` **string**, `Barcode`), unique `(ItemId, SerialNo)` | Entity exists but **nothing creates rows** (see §2). |
+| Ledger / layers | `StockLedger.BatchId/SerialId`, `StockLayer.BatchId/SerialId` | Columns exist; `SerialId` is always written `null` today. |
+| Expiry block | `FifoCostingService.ConsumeAsync` excludes expired batches, throws `EXPIRED_BATCH_BLOCKED` for an explicit expired batch | |
+| Warranty numbers at GRN | `GrnLineWarrantyNumber` — one per received unit, period snapshotted from item | Unique only per GRN line, not globally. |
+| Sales slip | `SalesSlipLine.BatchId/SerialId`; `SalesPostingService` passes batch to FIFO and flips `Serial.Status = "Sold"` | |
+| Scan lookup | `ItemService` scan resolves item / batch / serial by barcode or number | |
+| Counts | `CountService` snapshots per batch and per serial | Serial branch relies on per-serial layers that never exist. |
+
+## 2. Gaps found (the actual work)
+
+1. **Serials are never received.** `CreateGrnLineInput` has no serial field (frontend `types/grn.ts`
+   documents this as "KNOWN GAP"), `GrnService` never creates `Serial` rows, and
+   `ConfirmAsync` creates one layer per line with `serialId: null`. A `Serial`-mode item can be
+   received with no serials at all.
+2. **FIFO cannot consume a specific serial.** `ConsumeAsync` takes `batchId` only; the slip posting
+   flips the serial to `Sold` without proving that serial's stock was the stock consumed.
+3. **Sales invoices drop batch/serial.** `SalesInvoiceLine` has no `BatchId`/`SerialId`;
+   `PostInvoiceAsync` passes `null, null` (`SalesPostingService.cs:166`). The invoice UI carries
+   them as display-only metadata. Bundle sales also pass `null, null`.
+4. **Tracking is never mandatory on issue.** A batch- or serial-tracked item can be sold, transferred,
+   or adjusted with no batch/serial, so batch balances and serial status drift.
+5. **No FEFO.** Consumption orders by `ReceiptDate`, although `Batch` docs say "expiry drives FEFO".
+6. **Warranty never starts.** `GrnLineWarrantyNumber` records a period, but nothing records the sale
+   date, customer, or expiry date, and there is no lookup.
+7. **Returns lose identity.** `SalesReturnService` restocks via `StockDelta(itemId, null, null, qty)`
+   — no batch, no serial status change, warranty not voided. `PurchaseReturnService` likewise
+   ignores serials.
+8. **Transfers/adjustments** carry `BatchId` only; serial location is never tracked.
+9. **`Serial.Status` is a free string** (`"InStock"`, `"Sold"`) — no enum, no validation.
+
+## 3. Decisions needed before Phase 1 (Phase 0)
+
+| # | Question | Recommendation |
+|---|---|---|
+| D1 | Warranty number vs serial number — for a `Serial` + `Warranty` item, are they the same identifier? | **Yes, use the serial as the warranty identity** and skip `WarrantyNumbers` for serial items. Keep `GrnLineWarrantyNumber` only for warranty items with `TrackingMode = None`. |
+| D2 | Should `Warranty = Warranty` require `TrackingMode = Serial`? | Not forced now (would break existing items); revisit after D1 ships. |
+| D3 | Which document starts warranty? | **Posting of the stock-consuming sale**: slip, invoice and bundle all go through `SalesPostingService.PostAsync`, so one hook covers all three. This settles the other plan's open Phase 13 question. |
+| D4 | One serial per sales line, or many? | **Many**: add a child `…LineSerial` table rather than forcing `Qty = 1` per line (`SalesSlipLine.SerialId` becomes legacy/compat). |
+| D5 | Batch item sold with no batch chosen | **Auto-allocate FEFO** server-side, splitting across batches. Record each allocation on the line. |
+| D6 | Legacy stock of serial items received before Phase 2 (layers with no serial) | Allow issuing serial-less stock **only while** untracked layers remain (`QtyRemaining > 0`, `SerialId IS NULL`); after that, a serial is required. Optionally a one-off "assign serials to existing stock" adjustment. |
+| D7 | Warranty start date: post date or a delivery date? | Post date (no delivery document exists). |
+
+## 4. Phases
+
+### Phase 1 — `Serial` hardening
+- `Domain/Enums/SerialStatus.cs`: `InStock, Reserved, Sold, ReturnedByCustomer, ReturnedToVendor, Damaged, Scrapped`.
+  Map with `HasConversion<string>()` in `BatchSerialConfiguration` — existing `"InStock"`/`"Sold"`
+  values stay valid, so no data migration is needed.
+- Add to `Serial`: `WarehouseId?`, `BinId?` (current location), `GrnLineId?` (provenance),
+  `ReceivedAt`, `CreatedAt`, `UpdatedAt`, `RowVersion`.
+- Index `(ItemId, Status)`, `(WarehouseId, ItemId, Status)`.
+
+### Phase 2 — GRN serial capture
+- `CreateGrnLineInput.SerialNumbers: List<string>?`; `GrnLineDto.Serials`.
+- New `GrnLineSerial` (`GrnLineId`, `SerialNo`), unique `(GrnLineId, SerialNo)` — the draft holds numbers only.
+- `GrnService.CreateAsync` → `ResolveSerialNumbers(item, input, qty)`, the same pattern as
+  `ResolveWarrantyNumbers`: required iff `TrackingMode == Serial`; count must equal `Qty`, and `Qty`
+  must be a whole number; trimmed, distinct within the request, and not already an existing `Serial` for the item;
+  rejected when the mode is not `Serial`. Per D1, a serial+warranty item does not need `WarrantyNumbers`.
+- `ConfirmAsync`: for serial lines create one `Serial` per number (`InStock`, warehouse/bin, `GrnLineId`)
+  and **one layer + one ledger row per serial (qty 1)** via the existing
+  `CreateInboundLayerAsync(..., serialId, ...)` / `PostLedgerAsync(..., serialId, ...)`. Re-check
+  uniqueness inside the transaction (a concurrent GRN could take the number). GL posting is unchanged.
+- Hold/reject: serials on an `OnHold`/`Rejected` line remain `InStock` but non-issuable through the existing layer filter.
+
+### Phase 3 — Serial-aware and FEFO consumption (`FifoCostingService`)
+- `ConsumeAsync(itemId, warehouseId, batchId, qty, ct, allowShortfall, serialIds = null)`: when
+  `serialIds` is given, issue exactly those layers (each must be open, qty 1, issuable) or throw a new
+  `SERIAL_NOT_AVAILABLE` (409).
+- Ordering: for `Batch` items with no batch given, order candidates by `b.ExpiryDate` (nulls last),
+  then `ReceiptDate`, which gives FEFO. `None` items keep pure FIFO.
+- New `AllocateBatchesAsync(itemId, warehouseId, qty)` → `[(batchId, qty)]` for D5 and for UI suggestions.
+- Keep the deliberate "settle shortfall layers before the batch filter" behaviour; add tests around it.
+
+### Phase 4 — Sales documents
+- New `SalesInvoiceLineAllocation` / `SalesSlipLineAllocation` (`LineId`, `BatchId?`, `SerialId?`, `Qty`),
+  following D4/D5. Request DTOs accept `batchId?` and `serialIds?`; existing `SalesSlipLine.SerialId`/`BatchId`
+  are still read for old documents.
+- Validation in `SalesDomainService` (shared by slip/invoice/bundle):
+  `Serial` → serial count equals `Qty + FreeQty`, each `InStock` in the line warehouse (D6 exception);
+  `Batch` → given batch has stock and is not expired, or none given → FEFO allocation on post.
+- `SalesPostingService.PostAsync`: `PostingLine` carries allocations; consume per allocation; one
+  ledger row per serial; serial → `Sold`, location cleared. Replace the current `null, null` for
+  invoices (line 166) and bundles (line 236).
+- Over-stock sale (`allowShortfall`) is not allowed for serial items (a serial cannot go negative).
+
+### Phase 5 — Warranty registration
+- New `WarrantyRegistration`: `ItemId`, `SerialId?`, `GrnLineWarrantyNumberId?`, `CustomerId?`,
+  `SourceDocType`/`SourceDocId`/`LineId`, `StartDate`, `PeriodMonths`, `EndDate`, `Status` (`Active`, `Voided`, `Claimed`).
+- Created in `PostAsync` after consumption for items with `Warranty = Warranty`:
+  `PeriodMonths` = the receipt snapshot (`GrnLineWarrantyNumber.WarrantyPeriodMonths`, or the item's
+  current `WarrantyPeriodMonths` for serial items) and `EndDate = StartDate.AddMonths(PeriodMonths)`.
+- For non-serial warranty items: the sale must name which warranty numbers leave (picker, the same
+  shape as serials), or else D1/D2 is revisited.
+- `GET /api/warranty?serialNo=|warrantyNo=|customerId=` → status and days remaining.
+
+### Phase 6 — Returns
+- `SalesReturnLine` gets `BatchId?` and serial allocations. `StockDelta` (`IStockMutator`) gets an
+  optional `SerialId`; `StockMutator` passes it to layer and ledger.
+- The return reason (existing `ReasonCode`) maps the serial to `InStock` (restock) or `Damaged`;
+  the batch restocks into the **same** batch; the matching `WarrantyRegistration` → `Voided`.
+- A serial can be returned only if it was sold on the referenced invoice line.
+- `PurchaseReturnService`: serial layers being returned → `ReturnedToVendor`.
+
+### Phase 7 — Transfers, adjustments, counts
+- `StockTransferLine` + `StockAdjustmentLine`: serial allocations; transfer moves the per-serial
+  layer and updates `Serial.WarehouseId/BinId`; a negative adjustment of a serial → `Scrapped`/`Damaged`.
+- `CountService` variance posting for serials: found → create layer + `InStock`; missing → consume + `Damaged`
+  (confirm wording with ops). Its existing serial snapshot starts working once Phase 2 writes per-serial layers.
+- Production (`ProductionRunService` blocks tracked finished goods) — **out of scope**, unchanged.
+
+### Phase 8 — Frontend (`Frontend/erp-system`)
+- `receiving/grn/new`: per-line serial entry for `Serial` items (scan field — Enter adds; paste list;
+  auto-generate prefix + start; "n of N" counter; save disabled until complete). Remove the
+  "KNOWN GAP" note in `types/grn.ts` and add rules in `lib/validations/grn.ts`. Hide warranty-number
+  entry for serial items (D1).
+- `receiving/grn/[id]`: show serials per line (collapsible).
+- Sales slip / invoice / bundle: serial picker (scan or search `InStock` serials in the line warehouse)
+  and batch picker with expiry and FEFO suggestion; turn the existing scan metadata into real request fields.
+- Sales return: pick serials and batches from the original invoice line.
+- New `stock/serials` (search by serial → status, location, GRN, sale, warranty) and a warranty lookup.
+
+### Phase 9 — Reports
+- Stock on hand by batch, with expiry; "expiring in N days" (feeds the notification module —
+  `NotificationModuleCatalog`).
+- Serial register / history (from `StockLedger.SerialId`).
+- Warranty register: active, expiring, expired.
+
+### Phase 10 — Migration + tests
+- One EF migration per phase group (1–2, 3–4, 5–7). **This is MySQL/MariaDB**: re-check any CHECK
+  constraints for the quoting issue fixed in `20261005190000_FixCheckConstraintQuotingForMySql`, and
+  note that entity comments still mention PostgreSQL `xmin` for `RowVersion`.
+- Backfill: none required (status values are compatible; legacy layers are handled by D6).
+- Tests (`Testing/`): GRN serial validation and duplicate race; FEFO order with expired/null-expiry
+  batches; serial issue on slip, invoice, and bundle; shortfall blocked for serials; return restores
+  status and voids warranty; transfer moves serial location; count variance for serials.
+
+## 5. Execution order
+
+```
+Phase 0 → 1 → 2 → 3 → 4 → 5 → 6 → 7     (backend, sequential: shared FifoCostingService / SalesPostingService)
+Phase 8 starts per screen once its backend phase lands (GRN after 2, sales after 4, returns after 6)
+Phase 9 after 5 · Phase 10 alongside each group
+```
+
+Smallest shippable slice: **Phases 1 + 2 + GRN UI** (serials can be received correctly). Next:
+**3 + 4 + 5** (sell with serial/batch, warranty starts).
+
+## 6. As built — differences from the plan
+
+| Plan said | Built | Why |
+|---|---|---|
+| One stock-ledger row per serial | Ledger stays **one row per document line** (per batch for FEFO splits); new append-only **`SerialMovement`** table records every serial status/location change | `FifoCostingService.PostLedgerAsync` posts a GL journal per ledger row — per-serial rows would mean one GL call per unit |
+| Warranty period read from the item at sale (serial items) | Snapshotted onto **`Serial.WarrantyPeriodMonths`** at GRN confirm | Same rule as `GrnLineWarrantyNumber` — later item edits don't change stock already received |
+| `SalesInvoiceLineAllocation` / `SalesSlipLineAllocation` | Draft choices in **`SalesInvoiceLineSerial` / `SalesSlipLineSerial`**; what posting actually issued in one polymorphic **`SalesLineAllocation`** (doc type/id/line, batch, serial, qty, cost, qtyReturned) | Invoices, slips and bundles share one posting path; returns read one table |
+| Transfer: serial allocations on the line | **`StockTransferLineSerial`** (+ per-serial cost/batch from dispatch) and new status **`InTransit`** | A serial must be in no warehouse between dispatch and receive |
+| Batch item transfer with no batch | Server **splits the line FEFO into one line per batch at create** | Otherwise the batch is lost when the destination layer is created |
+| Count: missing serial → `Damaged` | Missing → **`Scrapped`**, found → `InStock` | A unit that can't be found isn't "damaged" |
+| Return reason → serial status | `DEF`/`QREJ` ⇒ `Damaged`, else `InStock`; request `markDamaged` overrides | Reason codes are user data — the flag keeps it explicit |
+| — | Pickers live on **`api/v1/tracking`** (base ERP access); registers on `api/v1/serials` (stock), `api/v1/warranties` (sales), `api/v1/stock/batches` | Sales, GRN and stock screens all need the pickers |
+
+**Bugs fixed on the way**: count posting dropped `BatchId` on batch lines; the count's serial snapshot
+wasn't warehouse-scoped; the GRN form never sent a batch expiry date (FEFO had nothing to sort on).
+
+**New error codes**: `SERIAL_DUPLICATE`, `SERIAL_NOT_AVAILABLE`, `TRACKING_REQUIRED`.
+
+**Frontend**: GRN "Serial / warranty numbers" tab (serial items: scan/paste, no auto-generated
+numbers) + batch expiry input; GRN detail shows batch/serials; `LineTrackingPicker` on sales invoice
+(new + edit), transfer and adjustment forms; serial ticking on sales and purchase return forms; new
+pages Stock → Serials, Stock → Batch Expiry, Sales → Warranties (sidebar reuses existing nav codes).
+
+**Auto-generated serial numbers (GRN)**: the serial tab has *Prefix* (default `SKU-`) + *Auto-generate*.
+`GET /tracking/serials/next-numbers?itemId&prefix&count` continues the highest number already used
+under that prefix for the item (received serials and draft-GRN numbers), zero-padded to ≥ 4 digits;
+the form also skips numbers already typed on it and fills **only empty units**, so scanned
+manufacturer serials are never overwritten. Nothing is reserved — the GRN's own uniqueness check
+on save and confirm remains the guard.
+
+## 8. Serial numbers on/off switch
+
+**Products → Configuration → Serial numbers** (`ProductConfig.SerialNumbersEnabled`) now governs
+serial tracking at runtime, not just item creation. Read through `ISerialTrackingService.IsEnabledAsync`
+(backend) and `GET /tracking/settings` + `useTrackingSettings()` (frontend; any logged-in user).
+
+| | On | Off |
+|---|---|---|
+| GRN | one serial per unit required | no serials; sending some → `CONFIG_DISABLED`; serial+warranty items take warranty numbers again |
+| Sales / returns / transfers / adjustments / counts | serials required (D6 exception) | serial items behave as untracked stock; serials refused with `CONFIG_DISABLED` |
+| Stock issue (FIFO) | serial layers only leave by naming the serial | serial layers issued oldest-first like any stock; their serials become **`IssuedUntracked`** (purchase return of a rejected line → `ReturnedToVendor`) |
+| Item edit | — | items already on Serial/Batch can still be edited (only switching *to* a disabled mode is refused) |
+| UI | pickers, GRN serial tab, Serials page | hidden; Serials page (if opened) shows a notice; history kept |
+
+No schema change (`IssuedUntracked` is a new string value). Switching back on resumes tracking for
+stock received from then on; units issued while off are not re-identified.
+
+## 7. Still open
+
+- **Apply the migration** (next backend start, or `dotnet ef database update`) — the dev connection
+  string points at the shared remote MariaDB.
+- **Bundle sales and free issues** have no serial picker: a serial item there can only post from
+  pre-tracking stock, otherwise it fails with `TRACKING_REQUIRED`.
+- **Transfer receive UI** sends qty only: receiving *all* outstanding serials works; a *partial*
+  receive of a serial line needs `serialIds` (API supports it, the screen doesn't).
+- **Non-serial warranty items**: warranty registered per sales line by quantity; choosing which GRN
+  warranty numbers leave (Phase 5 picker) is not built.
+- **Expiring-batch notifications** (`NotificationModuleCatalog`) not wired; the Batch Expiry page covers it manually.
+- **Tests**: FIFO/FEFO and posting paths use MariaDB-only SQL, so they are not unit-tested — needs an
+  e2e/integration pass (Testing/e2e) on a real database: GRN serials → sell → return → transfer → count.
+- Production of tracked finished goods — unchanged (still blocked), out of scope.