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..222b69b
--- /dev/null
+++ b/Backend/ERPCore.Tests/DualApprovalTests.cs
@@ -0,0 +1,388 @@
+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.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 ConfigurationBuilder().Build(),
+                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/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..6cc9501
--- /dev/null
+++ b/Backend/ERPCore.Tests/TestSupport/BankDepositTestSupport.cs
@@ -0,0 +1,168 @@
+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>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/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/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/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/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/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/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 bcbcc84..ecab917 100644
--- a/Backend/ERPCore/Domain/Entities/StockAdjustmentLine.cs
+++ b/Backend/ERPCore/Domain/Entities/StockAdjustmentLine.cs
@@ -21,4 +21,12 @@ public class StockAdjustmentLine
     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/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/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/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/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 52a51b2..77cd30d 100644
--- a/Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs
+++ b/Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs
@@ -31,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; }
@@ -47,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>
diff --git a/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs b/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs
index 9c80883..37af479 100644
--- a/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs
+++ b/Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs
@@ -12,7 +12,7 @@ public sealed record SalesSlipLineDto(
 
 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,
@@ -87,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
@@ -98,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 1efd1a1..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, int? SerialId);
+/// <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 ----------------------------------------------------------------------
 
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/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/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/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 4c71e15..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();
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 2299db2..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,6 +38,8 @@ 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);
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 95105d4..7b6b31e 100644
--- a/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs
+++ b/Backend/ERPCore/Infra/Persistence/ErpDbContext.cs
@@ -90,6 +90,22 @@ 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>();
@@ -221,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/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 c32dfc2..e09569e 100644
--- a/Backend/ERPCore/Migrations/ErpDbContextModelSnapshot.cs
+++ b/Backend/ERPCore/Migrations/ErpDbContextModelSnapshot.cs
@@ -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")
@@ -1989,6 +2219,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")
@@ -3343,6 +3632,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
                         });
                 });
 
@@ -3390,6 +3715,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")
@@ -4910,6 +5360,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)");
@@ -5112,6 +5569,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");
 
@@ -5549,9 +6014,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)");
 
@@ -5570,17 +6050,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");
@@ -5596,6 +6092,8 @@ namespace ERPCore.Migrations
 
                     b.HasIndex("ReasonCodeId");
 
+                    b.HasIndex("Status");
+
                     b.HasIndex("WarehouseId");
 
                     b.ToTable("stock_adjustments", (string)null);
@@ -5625,6 +6123,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");
 
@@ -6189,6 +6695,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",
@@ -6229,6 +6745,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",
@@ -6263,12 +6789,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",
@@ -6429,6 +6965,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",
@@ -7245,6 +7811,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")
@@ -7415,6 +8000,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")
@@ -7746,6 +8342,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")
@@ -7985,6 +8599,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")
@@ -9377,6 +10021,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");
@@ -9419,6 +10073,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");
diff --git a/Backend/ERPCore/Program.cs b/Backend/ERPCore/Program.cs
index fe20411..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,16 +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 7791412..3642694 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,27 +17,36 @@ 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;
@@ -53,18 +64,19 @@ public sealed class AdjustmentService : IAdjustmentService
         _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)
     {
@@ -99,7 +111,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();
 
@@ -112,13 +124,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);
@@ -129,20 +143,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);
@@ -157,77 +173,300 @@ 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);
 
-        // Serials per line: outbound ones are validated as on hand; inbound ones are created (or
-        // re-found) in the context now and get their ids on the flush below.
-        var serialsByLine = new List<IReadOnlyList<Serial>>();
-        var documentSerials = new HashSet<int>();
-        var documentSerialNos = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        // 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);
             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);
-            serialsByLine.Add(line.QtyDelta < 0
-                ? await _serialTracking.ResolveOutboundAsync(item, request.WarehouseId, -line.QtyDelta, line.SerialIds,
-                    documentSerials, new[] { SerialStatus.InStock, SerialStatus.Damaged }, ct)
-                : await _serialTracking.ResolveInboundAsync(item, request.WarehouseId, line.QtyDelta, line.SerialNos, documentSerialNos, ct));
+            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 (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, i) => new StockAdjustmentLine
+                Lines = request.Lines.Select(l => new StockAdjustmentLine
                 {
                     ItemId = l.ItemId,
                     BinId = l.BinId,
                     BatchId = l.BatchId,
                     QtyDelta = l.QtyDelta,
-                    Serial = serialsByLine[i].Count == 1 ? serialsByLine[i][0] : null
+                    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 (and new SerialIds) are valid
 
-            var deltas = request.Lines.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(request.WarehouseId, DocumentTypes.Adjustment, entity.AdjustmentId, now, deltas, token);
-
-            for (var i = 0; i < request.Lines.Count; i++)
+            IReadOnlyList<StockLedger> posted = [];
+            if (required == 0)
             {
-                var line = request.Lines[i];
-                await _serialTracking.MoveAsync(serialsByLine[i],
-                    line.QtyDelta < 0 ? SerialStatus.Scrapped : SerialStatus.InStock,
-                    line.QtyDelta < 0 ? null : request.WarehouseId, line.QtyDelta < 0 ? null : line.BinId,
-                    DocumentTypes.Adjustment, entity.AdjustmentId, now, token);
+                await _uow.SaveChangesAsync(token); // flush so AdjustmentId is a valid ledger sourceDocId
+                posted = await PostInCurrentTransactionAsync(entity, token);
             }
-
-            entity.GlJournalNo = await PostAdjustmentJournalAsync(docNo, now, refs, token);
-            if (entity.GlJournalNo is not null) entity.GlPostedAt = now;
-
-            return (entity, refs);
+            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, l.SerialId)).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 1011121..cd02c5b 100644
--- a/Backend/ERPCore/Services/CountService.cs
+++ b/Backend/ERPCore/Services/CountService.cs
@@ -16,53 +16,47 @@ 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;
 
     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)
     {
         _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;
@@ -266,13 +260,9 @@ public sealed class CountService : ICountService
 
         // Batch and serial lines adjust exactly their own lot/unit.
         var varianceLines = count.Lines.Where(l => l.Variance.HasValue && l.Variance.Value != 0).ToList();
-        var deltas = varianceLines
-            .Select(l => new StockDelta(l.ItemId, l.BinId, l.BatchId, l.Variance!.Value,
-                l.SerialId is int serialId ? new List<int> { serialId } : null))
-            .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);
@@ -283,53 +273,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,
-                    BatchId = d.BatchId,
-                    SerialId = d.SerialIds?.FirstOrDefault(),
-                    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);
-
-            // A serial counted missing is written off (Scrapped); one found keeps/regains InStock here.
-            foreach (var line in varianceLines.Where(l => l.SerialId is not null))
-            {
-                var serial = await _serials.Query().FirstAsync(s => s.SerialId == line.SerialId, token);
-                var found = line.Variance > 0;
-                await _serialTracking.MoveAsync(new[] { serial },
-                    found ? SerialStatus.InStock : SerialStatus.Scrapped,
-                    found ? count.WarehouseId : null, found ? line.BinId : null,
-                    DocumentTypes.Count, count.CountId, now, 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/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/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/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/ItemService.cs b/Backend/ERPCore/Services/ItemService.cs
index 944d6e6..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()
@@ -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(
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/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/SalesMappingService.cs b/Backend/ERPCore/Services/SalesMappingService.cs
index 1aafd88..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(
diff --git a/Backend/ERPCore/Services/SalesSlipService.cs b/Backend/ERPCore/Services/SalesSlipService.cs
index fb8802e..9e713f9 100644
--- a/Backend/ERPCore/Services/SalesSlipService.cs
+++ b/Backend/ERPCore/Services/SalesSlipService.cs
@@ -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
         {
@@ -249,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);
@@ -263,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(
diff --git a/Backend/ERPCore/Services/Stock/FifoCostingService.cs b/Backend/ERPCore/Services/Stock/FifoCostingService.cs
index eeeb91e..18205e9 100644
--- a/Backend/ERPCore/Services/Stock/FifoCostingService.cs
+++ b/Backend/ERPCore/Services/Stock/FifoCostingService.cs
@@ -28,6 +28,7 @@ public sealed class FifoCostingService : IFifoCostingService
     private readonly IGeneralLedgerService _gl;
     private readonly IGlAccountConfigService _glAccounts;
 
+    /// <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,
@@ -312,6 +313,7 @@ public sealed class FifoCostingService : IFifoCostingService
             segments.Add(new ConsumedSegment(shortfall.LayerId, remaining, unitCost));
         }
 
+        _lowStock?.Track(itemId, warehouseId, qtyBase);
         return segments;
     }
 
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/System/Errors/ErrorCodes.cs b/Backend/ERPCore/System/Errors/ErrorCodes.cs
index 10b002f..57297c0 100644
--- a/Backend/ERPCore/System/Errors/ErrorCodes.cs
+++ b/Backend/ERPCore/System/Errors/ErrorCodes.cs
@@ -93,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";
@@ -104,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 7ff3bb5..fb17e25 100644
--- a/Backend/ERPCore/appsettings.Development.json
+++ b/Backend/ERPCore/appsettings.Development.json
@@ -12,6 +12,6 @@
     "BaseUrl": "http://localhost:5011"
   },
   "GeneralLedgerService": {
-    "BaseUrl": "http://localhost:5200/api/v1/"
+    "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/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 6478a7a..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"
@@ -43,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()
@@ -432,10 +436,24 @@ 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>
@@ -493,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>
@@ -515,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"
diff --git a/Frontend/erp-system/app/dashboard/products/[id]/page.tsx b/Frontend/erp-system/app/dashboard/products/[id]/page.tsx
index d9a6f93..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"]
@@ -37,6 +39,28 @@ import { toast } from "@/components/ui/toast"
 import LineChart from "@/components/ui/line-chart"
 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}`
@@ -107,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)
@@ -141,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() {
@@ -167,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])
 
@@ -265,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(
@@ -285,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)
@@ -324,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}`
   }
@@ -419,6 +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={JSON.stringify(item.reorder ?? [])}
+        itemId={item.itemId}
+        stockNature={item.stockNature}
+        settings={item.reorder ?? []}
+        warehouses={warehouses}
+        uomName={uomName(item.baseUomId)}
+        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">
@@ -660,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">
@@ -674,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">
@@ -688,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>
@@ -818,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>
@@ -827,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}
@@ -837,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 39952af..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[]>>({})
@@ -562,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),
@@ -663,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
@@ -794,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>
@@ -812,6 +884,7 @@ 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" required>Base UOM</Label>
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/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/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 52656cf..ea43eda 100644
--- a/Frontend/erp-system/app/dashboard/stock/adjustments/new/page.tsx
+++ b/Frontend/erp-system/app/dashboard/stock/adjustments/new/page.tsx
@@ -187,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)
     }
@@ -224,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" }))}>
@@ -413,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/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/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/components/Layouts/AppSidebar.tsx b/Frontend/erp-system/components/Layouts/AppSidebar.tsx
index a88f163..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,7 +41,6 @@ import {
   PackageCheck,
   PackageSearch,
   PackageX,
-  Percent,
   PlayCircle,
   PieChart,
   Receipt,
@@ -50,6 +52,7 @@ import {
   ShieldCheck,
   ShoppingCart,
   SlidersHorizontal,
+  Tags,
   Truck,
   Undo2,
   Users,
@@ -59,6 +62,7 @@ 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"
@@ -102,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",
@@ -135,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 },
     ],
   },
@@ -215,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 },
     ],
   },
   {
@@ -226,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 },
     ],
   },
@@ -239,6 +250,7 @@ function SidebarContent({
   onClose,
   pathname,
   isMobile,
+  approvalCount,
 }: {
   items: typeof navItems
   collapsed: boolean
@@ -246,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
 
@@ -367,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>
@@ -449,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
@@ -489,6 +517,7 @@ export function AppSidebar() {
           onCollapse={() => setCollapsed((v) => !v)}
           pathname={pathname}
           isMobile={false}
+          approvalCount={approvalCount}
         />
       </div>
 
@@ -525,6 +554,7 @@ export function AppSidebar() {
           onClose={() => setMobileOpen(false)}
           pathname={pathname}
           isMobile={true}
+          approvalCount={approvalCount}
         />
       </div>
     </>
diff --git a/Frontend/erp-system/components/Layouts/Header.tsx b/Frontend/erp-system/components/Layouts/Header.tsx
index 0f56717..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> = {
@@ -104,6 +107,7 @@ 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"
@@ -113,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/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
index c49a14f..43ac207 100644
--- a/Frontend/erp-system/components/sales/LineTrackingPicker.tsx
+++ b/Frontend/erp-system/components/sales/LineTrackingPicker.tsx
@@ -95,6 +95,15 @@ function SerialPicker({
 
   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
@@ -127,9 +136,22 @@ function SerialPicker({
             className="h-9 text-sm"
           />
           {error && <p className="text-xs text-destructive">{error}</p>}
-          <p className={cn("text-xs", complete ? "text-success" : "text-muted-foreground")}>
-            {selected.length} of {units} selected
-          </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 && (
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/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/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/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/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/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/sales.ts b/Frontend/erp-system/types/sales.ts
index 8ccf104..006e8fb 100644
--- a/Frontend/erp-system/types/sales.ts
+++ b/Frontend/erp-system/types/sales.ts
@@ -167,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
@@ -180,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
@@ -250,6 +263,9 @@ export interface SalesSlipTotals {
   grandTotal: number
   paidAmount: number
   balanceAmount: number
+  /** cashAmount + cardAmount === paidAmount. */
+  cashAmount: number
+  cardAmount: number
 }
 
 export interface SalesSlipSummary {
@@ -308,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
@@ -595,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 2492627..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"
@@ -165,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
@@ -177,6 +181,9 @@ export interface AdjustmentLine {
   /** 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 {
@@ -191,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 {
@@ -203,6 +227,8 @@ export interface StockAdjustmentSummary {
   createdAt: string
   lineCount: number
   glJournalNo: string | null
+  requiredApprovals: number
+  pendingLevel: number | null
 }
 
 export interface CreateAdjustmentLineInput {
@@ -287,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/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.