wip Bills

app/Enums/Accounting/BillStatus.php

             self::Void => 'gray',
         };
     }
+
+    public static function canBeOverdue(): array
+    {
+        return [
+            self::Partial,
+            self::Unpaid,
+        ];
+    }
 }

app/Filament/Company/Resources/Purchases/BillResource.php

 
 namespace App\Filament\Company\Resources\Purchases;
 
+use App\Enums\Accounting\BillStatus;
+use App\Enums\Accounting\PaymentMethod;
 use App\Filament\Company\Resources\Purchases\BillResource\Pages;
+use App\Filament\Tables\Actions\ReplicateBulkAction;
+use App\Filament\Tables\Filters\DateRangeFilter;
 use App\Models\Accounting\Adjustment;
 use App\Models\Accounting\Bill;
 use App\Models\Accounting\DocumentLineItem;
+use App\Models\Banking\BankAccount;
 use App\Models\Common\Offering;
-use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
 use Awcodes\TableRepeater\Components\TableRepeater;
 use Awcodes\TableRepeater\Header;
 use Carbon\CarbonInterface;
+use Closure;
 use Filament\Forms;
 use Filament\Forms\Form;
+use Filament\Notifications\Notification;
 use Filament\Resources\Resource;
+use Filament\Support\Enums\Alignment;
+use Filament\Support\Enums\MaxWidth;
 use Filament\Tables;
 use Filament\Tables\Table;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Auth;
                                     ->live()
                                     ->afterStateUpdated(function (Forms\Set $set, Forms\Get $get, $state) {
                                         $offeringId = $state;
-                                        $offeringRecord = Offering::with('purchaseTaxes')->find($offeringId);
+                                        $offeringRecord = Offering::with(['purchaseTaxes', 'purchaseDiscounts'])->find($offeringId);
 
                                         if ($offeringRecord) {
                                             $set('description', $offeringRecord->description);
                                         // Final total
                                         $total = $subtotal + ($taxAmount - $discountAmount);
 
-                                        return money($total, CurrencyAccessor::getDefaultCurrency(), true)->format();
+                                        return CurrencyConverter::formatToMoney($total);
                                     }),
                             ]),
                         Forms\Components\Grid::make(6)
                 Tables\Columns\TextColumn::make('amount_due')
                     ->label('Amount Due')
                     ->currency(),
+            ])
+            ->filters([
+                Tables\Filters\SelectFilter::make('vendor')
+                    ->relationship('vendor', 'name')
+                    ->searchable()
+                    ->preload(),
+                Tables\Filters\SelectFilter::make('status')
+                    ->options(BillStatus::class)
+                    ->native(false),
+                Tables\Filters\TernaryFilter::make('has_payments')
+                    ->label('Has Payments')
+                    ->queries(
+                        true: fn (Builder $query) => $query->whereHas('payments'),
+                        false: fn (Builder $query) => $query->whereDoesntHave('payments'),
+                    ),
+                DateRangeFilter::make('date')
+                    ->fromLabel('From Date')
+                    ->untilLabel('To Date')
+                    ->indicatorLabel('Date'),
+                DateRangeFilter::make('due_date')
+                    ->fromLabel('From Due Date')
+                    ->untilLabel('To Due Date')
+                    ->indicatorLabel('Due'),
+            ])
+            ->actions([
+                Tables\Actions\ActionGroup::make([
+                    Tables\Actions\EditAction::make(),
+                    Tables\Actions\ViewAction::make(),
+                    Tables\Actions\DeleteAction::make(),
+                    Bill::getReplicateAction(Tables\Actions\ReplicateAction::class),
+                    Tables\Actions\Action::make('recordPayment')
+                        ->label('Record Payment')
+                        ->stickyModalHeader()
+                        ->stickyModalFooter()
+                        ->modalFooterActionsAlignment(Alignment::End)
+                        ->modalWidth(MaxWidth::TwoExtraLarge)
+                        ->icon('heroicon-o-credit-card')
+                        ->visible(function (Bill $record) {
+                            return $record->canRecordPayment();
+                        })
+                        ->mountUsing(function (Bill $record, Form $form) {
+                            $form->fill([
+                                'posted_at' => now(),
+                                'amount' => $record->amount_due,
+                            ]);
+                        })
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Payment Recorded')
+                        ->form([
+                            Forms\Components\DatePicker::make('posted_at')
+                                ->label('Date'),
+                            Forms\Components\TextInput::make('amount')
+                                ->label('Amount')
+                                ->required()
+                                ->money()
+                                ->live(onBlur: true)
+                                ->helperText(function (Bill $record, $state) {
+                                    if (! CurrencyConverter::isValidAmount($state)) {
+                                        return null;
+                                    }
+
+                                    $amountDue = $record->getRawOriginal('amount_due');
+                                    $amount = CurrencyConverter::convertToCents($state);
+
+                                    if ($amount <= 0) {
+                                        return 'Please enter a valid positive amount';
+                                    }
+
+                                    $newAmountDue = $amountDue - $amount;
+
+                                    return match (true) {
+                                        $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue),
+                                        $newAmountDue === 0 => 'Bill will be fully paid',
+                                        default => 'Amount exceeds bill total by ' . CurrencyConverter::formatCentsToMoney(abs($newAmountDue)),
+                                    };
+                                })
+                                ->rules([
+                                    static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
+                                        if (! CurrencyConverter::isValidAmount($value)) {
+                                            $fail('Please enter a valid amount');
+                                        }
+                                    },
+                                ]),
+                            Forms\Components\Select::make('payment_method')
+                                ->label('Payment Method')
+                                ->required()
+                                ->options(PaymentMethod::class),
+                            Forms\Components\Select::make('bank_account_id')
+                                ->label('Account')
+                                ->required()
+                                ->options(BankAccount::query()
+                                    ->get()
+                                    ->pluck('account.name', 'id'))
+                                ->searchable(),
+                            Forms\Components\Textarea::make('notes')
+                                ->label('Notes'),
+                        ])
+                        ->action(function (Bill $record, Tables\Actions\Action $action, array $data) {
+                            $record->recordPayment($data);
+
+                            $action->success();
+                        }),
+                ]),
+            ])
+            ->bulkActions([
+                Tables\Actions\BulkActionGroup::make([
+                    Tables\Actions\DeleteBulkAction::make(),
+                    ReplicateBulkAction::make()
+                        ->label('Replicate')
+                        ->modalWidth(MaxWidth::Large)
+                        ->modalDescription('Replicating bills will also replicate their line items. Are you sure you want to proceed?')
+                        ->successNotificationTitle('Bills Replicated Successfully')
+                        ->failureNotificationTitle('Failed to Replicate Bills')
+                        ->databaseTransaction()
+                        ->deselectRecordsAfterCompletion()
+                        ->excludeAttributes([
+                            'status',
+                            'amount_paid',
+                            'amount_due',
+                            'created_by',
+                            'updated_by',
+                            'created_at',
+                            'updated_at',
+                            'bill_number',
+                            'date',
+                            'due_date',
+                            'paid_at',
+                        ])
+                        ->beforeReplicaSaved(function (Bill $replica) {
+                            $replica->status = BillStatus::Unpaid;
+                            $replica->bill_number = Bill::getNextDocumentNumber();
+                            $replica->date = now();
+                            $replica->due_date = now()->addDays($replica->company->defaultBill->payment_terms->getDays());
+                        })
+                        ->withReplicatedRelationships(['lineItems'])
+                        ->withExcludedRelationshipAttributes('lineItems', [
+                            'subtotal',
+                            'total',
+                            'created_by',
+                            'updated_by',
+                            'created_at',
+                            'updated_at',
+                        ]),
+                    Tables\Actions\BulkAction::make('recordPayments')
+                        ->label('Record Payments')
+                        ->icon('heroicon-o-credit-card')
+                        ->stickyModalHeader()
+                        ->stickyModalFooter()
+                        ->modalFooterActionsAlignment(Alignment::End)
+                        ->modalWidth(MaxWidth::TwoExtraLarge)
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Payments Recorded')
+                        ->failureNotificationTitle('Failed to Record Payments')
+                        ->deselectRecordsAfterCompletion()
+                        ->beforeFormFilled(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $cantRecordPayments = $records->contains(fn (Bill $bill) => ! $bill->canRecordPayment());
+
+                            if ($cantRecordPayments) {
+                                Notification::make()
+                                    ->title('Payment Recording Failed')
+                                    ->body('Bills that are either paid or voided cannot be processed through bulk payments. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->mountUsing(function (Collection $records, Form $form) {
+                            $totalAmountDue = $records->sum(fn (Bill $bill) => $bill->getRawOriginal('amount_due'));
+
+                            $form->fill([
+                                'posted_at' => now(),
+                                'amount' => CurrencyConverter::convertCentsToFormatSimple($totalAmountDue),
+                            ]);
+                        })
+                        ->form([
+                            Forms\Components\DatePicker::make('posted_at')
+                                ->label('Date'),
+                            Forms\Components\TextInput::make('amount')
+                                ->label('Amount')
+                                ->required()
+                                ->money()
+                                ->rules([
+                                    static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
+                                        if (! CurrencyConverter::isValidAmount($value)) {
+                                            $fail('Please enter a valid amount');
+                                        }
+                                    },
+                                ]),
+                            Forms\Components\Select::make('payment_method')
+                                ->label('Payment Method')
+                                ->required()
+                                ->options(PaymentMethod::class),
+                            Forms\Components\Select::make('bank_account_id')
+                                ->label('Account')
+                                ->required()
+                                ->options(BankAccount::query()
+                                    ->get()
+                                    ->pluck('account.name', 'id'))
+                                ->searchable(),
+                            Forms\Components\Textarea::make('notes')
+                                ->label('Notes'),
+                        ])
+                        ->before(function (Collection $records, Tables\Actions\BulkAction $action, array $data) {
+                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
+                            $totalAmountDue = $records->sum(fn (Bill $bill) => $bill->getRawOriginal('amount_due'));
+
+                            if ($totalPaymentAmount > $totalAmountDue) {
+                                $formattedTotalAmountDue = CurrencyConverter::formatCentsToMoney($totalAmountDue);
+
+                                Notification::make()
+                                    ->title('Excess Payment Amount')
+                                    ->body("The payment amount exceeds the total amount due of {$formattedTotalAmountDue}. Please adjust the payment amount and try again.")
+                                    ->persistent()
+                                    ->warning()
+                                    ->send();
+
+                                $action->halt(true);
+                            }
+                        })
+                        ->action(function (Collection $records, Tables\Actions\BulkAction $action, array $data) {
+                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
+                            $remainingAmount = $totalPaymentAmount;
+
+                            $records->each(function (Bill $record) use (&$remainingAmount, $data) {
+                                $amountDue = $record->getRawOriginal('amount_due');
+
+                                if ($amountDue <= 0 || $remainingAmount <= 0) {
+                                    return;
+                                }
+
+                                $paymentAmount = min($amountDue, $remainingAmount);
+                                $data['amount'] = CurrencyConverter::convertCentsToFormatSimple($paymentAmount);
+
+                                $record->recordPayment($data);
+                                $remainingAmount -= $paymentAmount;
+                            });
+
+                            $action->success();
+                        }),
+                ]),
             ]);
     }
 
             'edit' => Pages\EditBill::route('/{record}/edit'),
         ];
     }
+
+    public static function getWidgets(): array
+    {
+        return [
+            BillResource\Widgets\BillOverview::class,
+        ];
+    }
 }

app/Filament/Company/Resources/Purchases/BillResource/Pages/ListBills.php

 
 namespace App\Filament\Company\Resources\Purchases\BillResource\Pages;
 
+use App\Enums\Accounting\BillStatus;
 use App\Filament\Company\Resources\Purchases\BillResource;
+use App\Models\Accounting\Bill;
 use Filament\Actions;
+use Filament\Pages\Concerns\ExposesTableToWidgets;
+use Filament\Resources\Components\Tab;
 use Filament\Resources\Pages\ListRecords;
 use Filament\Support\Enums\MaxWidth;
+use Illuminate\Database\Eloquent\Builder;
 
 class ListBills extends ListRecords
 {
+    use ExposesTableToWidgets;
+
     protected static string $resource = BillResource::class;
 
     protected function getHeaderActions(): array
         ];
     }
 
+    protected function getHeaderWidgets(): array
+    {
+        return [
+            BillResource\Widgets\BillOverview::class,
+        ];
+    }
+
     public function getMaxContentWidth(): MaxWidth | string | null
     {
         return 'max-w-8xl';
     }
+
+    public function getTabs(): array
+    {
+        return [
+            'all' => Tab::make()
+                ->label('All'),
+
+            'outstanding' => Tab::make()
+                ->label('Outstanding')
+                ->modifyQueryUsing(function (Builder $query) {
+                    $query->outstanding();
+                })
+                ->badge(Bill::outstanding()->count()),
+
+            'paid' => Tab::make()
+                ->label('Paid')
+                ->modifyQueryUsing(function (Builder $query) {
+                    $query->where('status', BillStatus::Paid);
+                })
+                ->badge(Bill::where('status', BillStatus::Paid)->count()),
+        ];
+    }
 }

app/Filament/Company/Resources/Purchases/BillResource/Widgets/BillOverview.php

+<?php
+
+namespace App\Filament\Company\Resources\Purchases\BillResource\Widgets;
+
+use App\Enums\Accounting\BillStatus;
+use App\Filament\Company\Resources\Purchases\BillResource\Pages\ListBills;
+use App\Filament\Widgets\EnhancedStatsOverviewWidget;
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use Filament\Widgets\Concerns\InteractsWithPageTable;
+use Illuminate\Support\Number;
+
+class BillOverview extends EnhancedStatsOverviewWidget
+{
+    use InteractsWithPageTable;
+
+    protected function getTablePage(): string
+    {
+        return ListBills::class;
+    }
+
+    protected function getStats(): array
+    {
+        $unpaidBills = $this->getPageTableQuery()
+            ->whereIn('status', [BillStatus::Unpaid, BillStatus::Partial, BillStatus::Overdue]);
+
+        $amountToPay = $unpaidBills->sum('amount_due');
+
+        $amountOverdue = $unpaidBills
+            ->clone()
+            ->where('status', BillStatus::Overdue)
+            ->sum('amount_due');
+
+        $amountDueWithin7Days = $unpaidBills
+            ->clone()
+            ->whereBetween('due_date', [today(), today()->addWeek()])
+            ->sum('amount_due');
+
+        $averagePaymentTime = $this->getPageTableQuery()
+            ->whereNotNull('paid_at')
+            ->selectRaw('AVG(TIMESTAMPDIFF(DAY, date, paid_at)) as avg_days')
+            ->value('avg_days');
+
+        $averagePaymentTimeFormatted = Number::format($averagePaymentTime ?? 0, maxPrecision: 1);
+
+        $lastMonthTotal = $this->getPageTableQuery()
+            ->where('status', BillStatus::Paid)
+            ->whereBetween('date', [
+                today()->subMonth()->startOfMonth(),
+                today()->subMonth()->endOfMonth(),
+            ])
+            ->sum('amount_paid');
+
+        return [
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Total To Pay', CurrencyConverter::formatCentsToMoney($amountToPay))
+                ->suffix(CurrencyAccessor::getDefaultCurrency())
+                ->description('Includes ' . CurrencyConverter::formatCentsToMoney($amountOverdue) . ' overdue'),
+
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Due Within 7 Days', CurrencyConverter::formatCentsToMoney($amountDueWithin7Days))
+                ->suffix(CurrencyAccessor::getDefaultCurrency()),
+
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Average Payment Time', $averagePaymentTimeFormatted)
+                ->suffix('days'),
+
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Paid Last Month', CurrencyConverter::formatCentsToMoney($lastMonthTotal))
+                ->suffix(CurrencyAccessor::getDefaultCurrency()),
+        ];
+    }
+}

app/Filament/Company/Resources/Sales/InvoiceResource.php

 use App\Models\Accounting\Invoice;
 use App\Models\Banking\BankAccount;
 use App\Models\Common\Offering;
-use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Awcodes\TableRepeater\Components\TableRepeater;
 use Awcodes\TableRepeater\Header;
                                         // Final total
                                         $total = $subtotal + ($taxAmount - $discountAmount);
 
-                                        return money($total, CurrencyAccessor::getDefaultCurrency(), true)->format();
+                                        return CurrencyConverter::formatToMoney($total);
                                     }),
                             ]),
                         Forms\Components\Grid::make(6)

app/Filament/Company/Resources/Sales/InvoiceResource/Pages/ListInvoices.php

             'unpaid' => Tab::make()
                 ->label('Unpaid')
                 ->modifyQueryUsing(function (Builder $query) {
-                    $query->whereIn('status', [
-                        InvoiceStatus::Unsent,
-                        InvoiceStatus::Sent,
-                        InvoiceStatus::Partial,
-                        InvoiceStatus::Overdue,
-                    ]);
+                    $query->unpaid();
                 })
-                ->badge(Invoice::whereIn('status', [
-                    InvoiceStatus::Unsent,
-                    InvoiceStatus::Sent,
-                    InvoiceStatus::Partial,
-                    InvoiceStatus::Overdue,
-                ])->count()),
+                ->badge(Invoice::unpaid()->count()),
 
             'draft' => Tab::make()
                 ->label('Draft')

app/Filament/Company/Resources/Sales/InvoiceResource/Widgets/InvoiceOverview.php

 
 use App\Enums\Accounting\InvoiceStatus;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Pages\ListInvoices;
+use App\Filament\Widgets\EnhancedStatsOverviewWidget;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Filament\Widgets\Concerns\InteractsWithPageTable;
-use Filament\Widgets\StatsOverviewWidget as BaseWidget;
-use Filament\Widgets\StatsOverviewWidget\Stat;
 use Illuminate\Support\Number;
 
-class InvoiceOverview extends BaseWidget
+class InvoiceOverview extends EnhancedStatsOverviewWidget
 {
     use InteractsWithPageTable;
 
-    protected static ?string $pollingInterval = null;
-
     protected function getTablePage(): string
     {
         return ListInvoices::class;
 
     protected function getStats(): array
     {
-        $outstandingInvoices = $this->getPageTableQuery()
-            ->whereNotIn('status', [
-                InvoiceStatus::Paid,
-                InvoiceStatus::Void,
-                InvoiceStatus::Draft,
-                InvoiceStatus::Overpaid,
-            ]);
+        $unpaidInvoices = $this->getPageTableQuery()->unpaid();
 
-        $amountOutstanding = $outstandingInvoices
-            ->clone()
-            ->sum('amount_due');
+        $amountUnpaid = $unpaidInvoices->sum('amount_due');
 
-        $amountOverdue = $outstandingInvoices
+        $amountOverdue = $unpaidInvoices
             ->clone()
             ->where('status', InvoiceStatus::Overdue)
             ->sum('amount_due');
 
-        $amountDueWithin30Days = $outstandingInvoices
+        $amountDueWithin30Days = $unpaidInvoices
             ->clone()
-            ->where('due_date', '>=', today())
-            ->where('due_date', '<=', today()->addDays(30))
+            ->whereBetween('due_date', [today(), today()->addMonth()])
             ->sum('amount_due');
 
         $validInvoices = $this->getPageTableQuery()
                 InvoiceStatus::Draft,
             ]);
 
-        $totalValidInvoiceAmount = $validInvoices->clone()->sum('amount_due');
+        $totalValidInvoiceAmount = $validInvoices->sum('total');
 
-        $totalValidInvoiceCount = $validInvoices->clone()->count();
+        $totalValidInvoiceCount = $validInvoices->count();
 
         $averageInvoiceTotal = $totalValidInvoiceCount > 0 ? $totalValidInvoiceAmount / $totalValidInvoiceCount : 0;
 
             ->selectRaw('AVG(TIMESTAMPDIFF(DAY, date, paid_at)) as avg_days')
             ->value('avg_days');
 
+        $averagePaymentTimeFormatted = Number::format($averagePaymentTime ?? 0, maxPrecision: 1);
+
         return [
-            Stat::make('Total Outstanding', CurrencyConverter::formatCentsToMoney($amountOutstanding))
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Total Unpaid', CurrencyConverter::formatCentsToMoney($amountUnpaid))
+                ->suffix(CurrencyAccessor::getDefaultCurrency())
                 ->description('Includes ' . CurrencyConverter::formatCentsToMoney($amountOverdue) . ' overdue'),
-            Stat::make('Due Within 30 Days', CurrencyConverter::formatCentsToMoney($amountDueWithin30Days)),
-            Stat::make('Average Payment Time', Number::format($averagePaymentTime ?? 0, maxPrecision: 1) . ' days')
-                ->description('From invoice date to payment received'),
-            Stat::make('Average Invoice Total', CurrencyConverter::formatCentsToMoney($averageInvoiceTotal))
-                ->description('Excludes void and draft invoices'),
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Due Within 30 Days', CurrencyConverter::formatCentsToMoney($amountDueWithin30Days))
+                ->suffix(CurrencyAccessor::getDefaultCurrency()),
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Average Payment Time', $averagePaymentTimeFormatted)
+                ->suffix('days'),
+            EnhancedStatsOverviewWidget\EnhancedStat::make('Average Invoice Total', CurrencyConverter::formatCentsToMoney($averageInvoiceTotal))
+                ->suffix(CurrencyAccessor::getDefaultCurrency()),
         ];
     }
 }

app/Filament/Widgets/EnhancedStatsOverviewWidget.php

+<?php
+
+namespace App\Filament\Widgets;
+
+use Filament\Widgets\StatsOverviewWidget;
+
+class EnhancedStatsOverviewWidget extends StatsOverviewWidget
+{
+    protected static ?string $pollingInterval = null;
+
+    protected static bool $isLazy = false;
+}

app/Filament/Widgets/EnhancedStatsOverviewWidget/EnhancedStat.php

+<?php
+
+namespace App\Filament\Widgets\EnhancedStatsOverviewWidget;
+
+use Closure;
+use Filament\Support\Concerns\EvaluatesClosures;
+use Filament\Widgets\StatsOverviewWidget\Stat;
+use Illuminate\Contracts\Support\Htmlable;
+use Illuminate\Contracts\View\View;
+
+class EnhancedStat extends Stat
+{
+    use EvaluatesClosures;
+
+    protected string | Htmlable | Closure | null $prefixLabel = null;
+
+    protected string | Htmlable | Closure | null $suffixLabel = null;
+
+    public function prefix(string | Htmlable | Closure | null $label): static
+    {
+        $this->prefixLabel = $label;
+
+        return $this;
+    }
+
+    public function suffix(string | Htmlable | Closure | null $label): static
+    {
+        $this->suffixLabel = $label;
+
+        return $this;
+    }
+
+    public function getPrefixLabel(): string | Htmlable | null
+    {
+        return $this->evaluate($this->prefixLabel);
+    }
+
+    public function getSuffixLabel(): string | Htmlable | null
+    {
+        return $this->evaluate($this->suffixLabel);
+    }
+
+    public function render(): View
+    {
+        return view('filament.widgets.enhanced-stats-overview-widget.enhanced-stat', $this->data());
+    }
+}

app/Models/Accounting/Account.php

         return self::where('name', 'Accounts Receivable')->firstOrFail();
     }
 
+    public static function getAccountsPayableAccount(): self
+    {
+        return self::where('name', 'Accounts Payable')->firstOrFail();
+    }
+
     protected static function newFactory(): Factory
     {
         return AccountFactory::new();

app/Models/Accounting/Bill.php

 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\BillStatus;
+use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\TransactionType;
+use App\Filament\Company\Resources\Purchases\BillResource;
 use App\Models\Common\Vendor;
+use App\Observers\BillObserver;
+use Filament\Actions\MountableAction;
+use Filament\Actions\ReplicateAction;
+use Illuminate\Database\Eloquent\Attributes\ObservedBy;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\MorphMany;
 use Illuminate\Database\Eloquent\Relations\MorphOne;
+use Illuminate\Support\Carbon;
 
+#[ObservedBy(BillObserver::class)]
 class Bill extends Model
 {
     use Blamable;
         'order_number',
         'date',
         'due_date',
+        'paid_at',
         'status',
         'currency_code',
         'subtotal',
         'discount_total',
         'total',
         'amount_paid',
+        'notes',
         'created_by',
         'updated_by',
     ];
     protected $casts = [
         'date' => 'date',
         'due_date' => 'date',
+        'paid_at' => 'datetime',
         'status' => BillStatus::class,
         'subtotal' => MoneyCast::class,
         'tax_total' => MoneyCast::class,
         return $this->transactions()->where('type', TransactionType::Withdrawal)->where('is_payment', true);
     }
 
-    public function approvalTransaction(): MorphOne
+    public function initialTransaction(): MorphOne
     {
         return $this->morphOne(Transaction::class, 'transactionable')
             ->where('type', TransactionType::Journal);
     }
 
+    protected function isCurrentlyOverdue(): Attribute
+    {
+        return Attribute::get(function () {
+            return $this->due_date->isBefore(today()) && $this->canBeOverdue();
+        });
+    }
+
+    public function canBeOverdue(): bool
+    {
+        return in_array($this->status, BillStatus::canBeOverdue());
+    }
+
+    public function canRecordPayment(): bool
+    {
+        return ! in_array($this->status, [
+            BillStatus::Paid,
+            BillStatus::Void,
+        ]);
+    }
+
     public static function getNextDocumentNumber(): string
     {
         $company = auth()->user()->currentCompany;
             next: $numberNext
         );
     }
+
+    public function hasInitialTransaction(): bool
+    {
+        return $this->initialTransaction()->exists();
+    }
+
+    public function scopeOutstanding(Builder $query): Builder
+    {
+        return $query->whereIn('status', [
+            BillStatus::Unpaid,
+            BillStatus::Partial,
+            BillStatus::Overdue,
+        ]);
+    }
+
+    public function recordPayment(array $data): void
+    {
+        $transactionType = TransactionType::Withdrawal;
+        $transactionDescription = 'Payment for Bill #' . $this->bill_number;
+
+        // Create transaction
+        $this->transactions()->create([
+            'company_id' => $this->company_id,
+            'type' => $transactionType,
+            'is_payment' => true,
+            'posted_at' => $data['posted_at'],
+            'amount' => $data['amount'],
+            'payment_method' => $data['payment_method'],
+            'bank_account_id' => $data['bank_account_id'],
+            'account_id' => Account::getAccountsPayableAccount()->id,
+            'description' => $transactionDescription,
+            'notes' => $data['notes'] ?? null,
+        ]);
+    }
+
+    public function createInitialTransaction(?Carbon $postedAt = null): void
+    {
+        $postedAt ??= now();
+
+        $transaction = $this->transactions()->create([
+            'company_id' => $this->company_id,
+            'type' => TransactionType::Journal,
+            'posted_at' => $postedAt,
+            'amount' => $this->total,
+            'description' => 'Bill Creation for Bill #' . $this->bill_number,
+        ]);
+
+        $transaction->journalEntries()->create([
+            'company_id' => $this->company_id,
+            'type' => JournalEntryType::Credit,
+            'account_id' => Account::getAccountsPayableAccount()->id,
+            'amount' => $this->total,
+            'description' => $transaction->description,
+        ]);
+
+        foreach ($this->lineItems as $lineItem) {
+            $transaction->journalEntries()->create([
+                'company_id' => $this->company_id,
+                'type' => JournalEntryType::Debit,
+                'account_id' => $lineItem->offering->expense_account_id,
+                'amount' => $lineItem->subtotal,
+                'description' => $transaction->description,
+            ]);
+
+            foreach ($lineItem->adjustments as $adjustment) {
+                if ($adjustment->isNonRecoverablePurchaseTax()) {
+                    $transaction->journalEntries()->create([
+                        'company_id' => $this->company_id,
+                        'type' => JournalEntryType::Debit,
+                        'account_id' => $lineItem->offering->expense_account_id,
+                        'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
+                        'description' => $transaction->description . " ($adjustment->name)",
+                    ]);
+                } elseif ($adjustment->account_id) {
+                    $transaction->journalEntries()->create([
+                        'company_id' => $this->company_id,
+                        'type' => $adjustment->category->isDiscount() ? JournalEntryType::Credit : JournalEntryType::Debit,
+                        'account_id' => $adjustment->account_id,
+                        'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
+                        'description' => $transaction->description,
+                    ]);
+                }
+            }
+        }
+    }
+
+    public static function getReplicateAction(string $action = ReplicateAction::class): MountableAction
+    {
+        return $action::make()
+            ->excludeAttributes([
+                'status',
+                'amount_paid',
+                'amount_due',
+                'created_by',
+                'updated_by',
+                'created_at',
+                'updated_at',
+                'bill_number',
+                'date',
+                'due_date',
+                'paid_at',
+            ])
+            ->modal(false)
+            ->beforeReplicaSaved(function (self $original, self $replica) {
+                $replica->status = BillStatus::Unpaid;
+                $replica->bill_number = self::getNextDocumentNumber();
+                $replica->date = now();
+                $replica->due_date = now()->addDays($original->company->defaultBill->payment_terms->getDays());
+            })
+            ->databaseTransaction()
+            ->after(function (self $original, self $replica) {
+                $original->lineItems->each(function (DocumentLineItem $lineItem) use ($replica) {
+                    $replicaLineItem = $lineItem->replicate([
+                        'documentable_id',
+                        'documentable_type',
+                        'subtotal',
+                        'total',
+                        'created_by',
+                        'updated_by',
+                        'created_at',
+                        'updated_at',
+                    ]);
+
+                    $replicaLineItem->documentable_id = $replica->id;
+                    $replicaLineItem->documentable_type = $replica->getMorphClass();
+
+                    $replicaLineItem->save();
+
+                    $replicaLineItem->adjustments()->sync($lineItem->adjustments->pluck('id'));
+                });
+            })
+            ->successRedirectUrl(static function (self $replica) {
+                return BillResource::getUrl('edit', ['record' => $replica]);
+            });
+    }
 }

app/Models/Accounting/Invoice.php

 use Filament\Actions\ReplicateAction;
 use Illuminate\Database\Eloquent\Attributes\CollectedBy;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
             ->where('type', TransactionType::Journal);
     }
 
+    public function scopeUnpaid(Builder $query): Builder
+    {
+        return $query->whereNotIn('status', [
+            InvoiceStatus::Paid,
+            InvoiceStatus::Void,
+            InvoiceStatus::Draft,
+            InvoiceStatus::Overpaid,
+        ]);
+    }
+
     protected function isCurrentlyOverdue(): Attribute
     {
         return Attribute::get(function () {
     public static function getReplicateAction(string $action = ReplicateAction::class): MountableAction
     {
         return $action::make()
-            ->excludeAttributes(['status', 'amount_paid', 'amount_due', 'created_by', 'updated_by', 'created_at', 'updated_at', 'invoice_number', 'date', 'due_date'])
+            ->excludeAttributes([
+                'status',
+                'amount_paid',
+                'amount_due',
+                'created_by',
+                'updated_by',
+                'created_at',
+                'updated_at',
+                'invoice_number',
+                'date',
+                'due_date',
+                'approved_at',
+                'paid_at',
+                'last_sent',
+            ])
             ->modal(false)
             ->beforeReplicaSaved(function (self $original, self $replica) {
                 $replica->status = InvoiceStatus::Draft;

app/Observers/BillObserver.php

+<?php
+
+namespace App\Observers;
+
+use App\Enums\Accounting\BillStatus;
+use App\Models\Accounting\Bill;
+use App\Models\Accounting\DocumentLineItem;
+use App\Models\Accounting\Transaction;
+use Illuminate\Support\Facades\DB;
+
+class BillObserver
+{
+    public function created(Bill $bill): void
+    {
+        // $bill->createInitialTransaction();
+    }
+
+    public function saving(Bill $bill): void
+    {
+        if ($bill->is_currently_overdue) {
+            $bill->status = BillStatus::Overdue;
+        }
+    }
+
+    /**
+     * Handle the Bill "deleted" event.
+     */
+    public function deleted(Bill $bill): void
+    {
+        DB::transaction(function () use ($bill) {
+            $bill->lineItems()->each(function (DocumentLineItem $lineItem) {
+                $lineItem->delete();
+            });
+
+            $bill->transactions()->each(function (Transaction $transaction) {
+                $transaction->delete();
+            });
+        });
+    }
+}

app/Observers/InvoiceObserver.php

 
 class InvoiceObserver
 {
-    /**
-     * Handle the Invoice "created" event.
-     */
-    public function created(Invoice $invoice): void
-    {
-        //
-    }
-
-    /**
-     * Handle the Invoice "updated" event.
-     */
-    public function updated(Invoice $invoice): void
-    {
-        //
-    }
-
-    public function deleting(Invoice $invoice): void
-    {
-        //
-    }
-
     public function saving(Invoice $invoice): void
     {
         if ($invoice->approved_at && $invoice->is_currently_overdue) {
             });
         });
     }
-
-    /**
-     * Handle the Invoice "restored" event.
-     */
-    public function restored(Invoice $invoice): void
-    {
-        //
-    }
-
-    /**
-     * Handle the Invoice "force deleted" event.
-     */
-    public function forceDeleted(Invoice $invoice): void
-    {
-        //
-    }
 }

app/Observers/TransactionObserver.php

 
 namespace App\Observers;
 
+use App\Enums\Accounting\BillStatus;
 use App\Enums\Accounting\InvoiceStatus;
+use App\Models\Accounting\Bill;
 use App\Models\Accounting\Invoice;
 use App\Models\Accounting\Transaction;
 use App\Services\TransactionService;
             return;
         }
 
-        $invoice = $transaction->transactionable;
+        $document = $transaction->transactionable;
 
-        if ($invoice instanceof Invoice) {
-            $this->updateInvoiceTotals($invoice);
+        if ($document instanceof Invoice) {
+            $this->updateInvoiceTotals($document);
+        } elseif ($document instanceof Bill) {
+            $this->updateBillTotals($document);
         }
     }
 
             return;
         }
 
-        $invoice = $transaction->transactionable;
+        $document = $transaction->transactionable;
 
-        if ($invoice instanceof Invoice) {
-            $this->updateInvoiceTotals($invoice);
+        if ($document instanceof Invoice) {
+            $this->updateInvoiceTotals($document);
+        } elseif ($document instanceof Bill) {
+            $this->updateBillTotals($document);
         }
     }
 
                 return;
             }
 
-            $invoice = $transaction->transactionable;
+            $document = $transaction->transactionable;
 
-            if ($invoice instanceof Invoice && ! $invoice->exists) {
+            if (($document instanceof Invoice || $document instanceof Bill) && ! $document->exists) {
                 return;
             }
 
-            if ($invoice instanceof Invoice) {
-                $this->updateInvoiceTotals($invoice, $transaction);
+            if ($document instanceof Invoice) {
+                $this->updateInvoiceTotals($document, $transaction);
+            } elseif ($document instanceof Bill) {
+                $this->updateBillTotals($document, $transaction);
             }
         });
     }
             'paid_at' => $paidAt,
         ]);
     }
+
+    protected function updateBillTotals(Bill $bill, ?Transaction $excludedTransaction = null): void
+    {
+        $withdrawalTotal = (int) $bill->withdrawals()
+            ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
+            ->sum('amount');
+
+        $totalPaid = $withdrawalTotal;
+        $billTotal = (int) $bill->getRawOriginal('total');
+
+        $newStatus = match (true) {
+            $totalPaid >= $billTotal => BillStatus::Paid,
+            default => BillStatus::Partial,
+        };
+
+        $paidAt = $bill->paid_at;
+
+        if ($newStatus === BillStatus::Paid && ! $paidAt) {
+            $paidAt = $bill->withdrawals()
+                ->latest('posted_at')
+                ->value('posted_at');
+        }
+
+        $bill->update([
+            'amount_paid' => CurrencyConverter::convertCentsToFloat($totalPaid),
+            'status' => $newStatus,
+            'paid_at' => $paidAt,
+        ]);
+    }
 }

app/Providers/MacroServiceProvider.php

 
             $currencyCode = $this->currency->getCurrency();
 
-            if ($currencyCode === CurrencyAccessor::getDefaultCurrency()) {
-                return $formatted;
-            }
-
             if ($codeBefore) {
                 return $currencyCode . ' ' . $formatted;
             }

app/Utilities/Currency/CurrencyConverter.php

         return money($amount, $currency, true)->getAmount();
     }
 
-    public static function formatCentsToMoney(int $amount, ?string $currency = null): string
+    public static function formatCentsToMoney(int $amount, ?string $currency = null, bool $withCode = false): string
     {
         $currency ??= CurrencyAccessor::getDefaultCurrency();
 
-        return money($amount, $currency)->format();
+        $money = money($amount, $currency);
+
+        if ($withCode) {
+            return $money->formatWithCode();
+        }
+
+        return $money->format();
     }
 
     public static function formatToMoney(string | float $amount, ?string $currency = null): string

composer.lock

         },
         {
             "name": "openspout/openspout",
-            "version": "v4.28.1",
+            "version": "v4.28.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/openspout/openspout.git",
-                "reference": "229a9c837bd768e8767660671f9fdf429f343a74"
+                "reference": "d6dd654b5db502f28c5773edfa785b516745a142"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/openspout/openspout/zipball/229a9c837bd768e8767660671f9fdf429f343a74",
-                "reference": "229a9c837bd768e8767660671f9fdf429f343a74",
+                "url": "https://api.github.com/repos/openspout/openspout/zipball/d6dd654b5db502f28c5773edfa785b516745a142",
+                "reference": "d6dd654b5db502f28c5773edfa785b516745a142",
                 "shasum": ""
             },
             "require": {
             ],
             "support": {
                 "issues": "https://github.com/openspout/openspout/issues",
-                "source": "https://github.com/openspout/openspout/tree/v4.28.1"
+                "source": "https://github.com/openspout/openspout/tree/v4.28.2"
             },
             "funding": [
                 {
                     "type": "github"
                 }
             ],
-            "time": "2024-12-05T13:34:00+00:00"
+            "time": "2024-12-06T06:17:37+00:00"
         },
         {
             "name": "paragonie/constant_time_encoding",

database/factories/Accounting/BillFactory.php

 
 namespace Database\Factories\Accounting;
 
+use App\Enums\Accounting\BillStatus;
+use App\Enums\Accounting\PaymentMethod;
+use App\Models\Accounting\Bill;
+use App\Models\Accounting\DocumentLineItem;
+use App\Models\Banking\BankAccount;
+use App\Models\Common\Vendor;
+use App\Utilities\Currency\CurrencyConverter;
 use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Carbon;
 
 /**
- * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Accounting\Bill>
+ * @extends Factory<Bill>
  */
 class BillFactory extends Factory
 {
+    /**
+     * The name of the factory's corresponding model.
+     */
+    protected $model = Bill::class;
+
     /**
      * Define the model's default state.
      *
      */
     public function definition(): array
     {
+        // 50% chance of being a future bill
+        $isFutureBill = $this->faker->boolean();
+
+        if ($isFutureBill) {
+            // For future bills, date is recent and due date is in near future
+            $billDate = $this->faker->dateTimeBetween('-10 days', '+10 days');
+        } else {
+            // For past bills, both date and due date are in the past
+            $billDate = $this->faker->dateTimeBetween('-1 year', '-30 days');
+        }
+
+        $dueDays = $this->faker->numberBetween(14, 60);
+
         return [
-            //
+            'company_id' => 1,
+            'vendor_id' => Vendor::inRandomOrder()->value('id'),
+            'bill_number' => $this->faker->unique()->numerify('BILL-#####'),
+            'order_number' => $this->faker->unique()->numerify('PO-#####'),
+            'date' => $billDate,
+            'due_date' => Carbon::parse($billDate)->addDays($dueDays),
+            'status' => BillStatus::Unpaid,
+            'currency_code' => 'USD',
+            'notes' => $this->faker->sentence,
+            'created_by' => 1,
+            'updated_by' => 1,
         ];
     }
+
+    public function withLineItems(int $count = 3): self
+    {
+        return $this->has(DocumentLineItem::factory()->forBill()->count($count), 'lineItems');
+    }
+
+    public function initialized(): static
+    {
+        return $this->afterCreating(function (Bill $bill) {
+            if ($bill->hasInitialTransaction()) {
+                return;
+            }
+
+            $this->recalculateTotals($bill);
+
+            $postedAt = Carbon::parse($bill->date)->addHours($this->faker->numberBetween(1, 24));
+
+            $bill->createInitialTransaction($postedAt);
+        });
+    }
+
+    public function withPayments(?int $min = 1, ?int $max = null, BillStatus $billStatus = BillStatus::Paid): static
+    {
+        return $this->afterCreating(function (Bill $bill) use ($billStatus, $max, $min) {
+            if (! $bill->hasInitialTransaction()) {
+                $this->recalculateTotals($bill);
+
+                $postedAt = Carbon::parse($bill->date)->addHours($this->faker->numberBetween(1, 24));
+
+                $bill->createInitialTransaction($postedAt);
+            }
+
+            $bill->refresh();
+
+            $totalAmountDue = $bill->getRawOriginal('amount_due');
+
+            if ($billStatus === BillStatus::Partial) {
+                $totalAmountDue = (int) floor($totalAmountDue * 0.5);
+            }
+
+            if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
+                return;
+            }
+
+            $paymentCount = $max && $min ? $this->faker->numberBetween($min, $max) : $min;
+            $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
+            $remainingAmount = $totalAmountDue;
+
+            $paymentDate = Carbon::parse($bill->initialTransaction->posted_at);
+            $paymentDates = [];
+
+            for ($i = 0; $i < $paymentCount; $i++) {
+                $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
+
+                if ($amount <= 0) {
+                    break;
+                }
+
+                $postedAt = $paymentDate->copy()->addDays($this->faker->numberBetween(1, 30));
+                $paymentDates[] = $postedAt;
+
+                $data = [
+                    'posted_at' => $postedAt,
+                    'amount' => CurrencyConverter::convertCentsToFormatSimple($amount, $bill->currency_code),
+                    'payment_method' => $this->faker->randomElement(PaymentMethod::class),
+                    'bank_account_id' => BankAccount::inRandomOrder()->value('id'),
+                    'notes' => $this->faker->sentence,
+                ];
+
+                $bill->recordPayment($data);
+                $remainingAmount -= $amount;
+            }
+
+            if ($billStatus === BillStatus::Paid) {
+                $latestPaymentDate = max($paymentDates);
+                $bill->updateQuietly([
+                    'status' => $billStatus,
+                    'paid_at' => $latestPaymentDate,
+                ]);
+            }
+        });
+    }
+
+    public function configure(): static
+    {
+        return $this->afterCreating(function (Bill $bill) {
+            $paddedId = str_pad((string) $bill->id, 5, '0', STR_PAD_LEFT);
+
+            $bill->updateQuietly([
+                'bill_number' => "BILL-{$paddedId}",
+                'order_number' => "PO-{$paddedId}",
+            ]);
+
+            $this->recalculateTotals($bill);
+
+            // Check for overdue status
+            if ($bill->due_date < today() && $bill->status !== BillStatus::Paid) {
+                $bill->updateQuietly([
+                    'status' => BillStatus::Overdue,
+                ]);
+            }
+        });
+    }
+
+    protected function recalculateTotals(Bill $bill): void
+    {
+        if ($bill->lineItems()->exists()) {
+            $bill->refresh();
+            $subtotal = $bill->lineItems()->sum('subtotal') / 100;
+            $taxTotal = $bill->lineItems()->sum('tax_total') / 100;
+            $discountTotal = $bill->lineItems()->sum('discount_total') / 100;
+            $grandTotal = $subtotal + $taxTotal - $discountTotal;
+
+            $bill->update([
+                'subtotal' => $subtotal,
+                'tax_total' => $taxTotal,
+                'discount_total' => $discountTotal,
+                'total' => $grandTotal,
+            ]);
+        }
+    }
 }

database/factories/Accounting/DocumentLineItemFactory.php

      */
     public function definition(): array
     {
-        $offering = Offering::with(['salesTaxes', 'salesDiscounts'])->inRandomOrder()->first();
-
         $quantity = $this->faker->numberBetween(1, 10);
-        $unitPrice = $offering->price;
 
         return [
             'company_id' => 1,
-            'offering_id' => $offering->id,
             'description' => $this->faker->sentence,
             'quantity' => $quantity,
-            'unit_price' => $unitPrice,
             'created_by' => 1,
             'updated_by' => 1,
         ];
     }
 
-    public function configure(): static
+    public function forInvoice(): static
     {
-        return $this->afterCreating(function (DocumentLineItem $lineItem) {
+        return $this->state(function (array $attributes) {
+            $offering = Offering::with(['salesTaxes', 'salesDiscounts'])
+                ->where('sellable', true)
+                ->inRandomOrder()
+                ->first();
+
+            return [
+                'offering_id' => $offering->id,
+                'unit_price' => $offering->price,
+            ];
+        })->afterCreating(function (DocumentLineItem $lineItem) {
+            $offering = $lineItem->offering;
+
+            if ($offering) {
+                $lineItem->adjustments()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
+                $lineItem->adjustments()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
+            }
+
+            $lineItem->refresh();
+
+            $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
+            $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
+
+            $lineItem->updateQuietly([
+                'tax_total' => $taxTotal,
+                'discount_total' => $discountTotal,
+            ]);
+        });
+    }
+
+    public function forBill(): static
+    {
+        return $this->state(function (array $attributes) {
+            $offering = Offering::with(['purchaseTaxes', 'purchaseDiscounts'])
+                ->where('purchasable', true)
+                ->inRandomOrder()
+                ->first();
+
+            return [
+                'offering_id' => $offering->id,
+                'unit_price' => $offering->price,
+            ];
+        })->afterCreating(function (DocumentLineItem $lineItem) {
             $offering = $lineItem->offering;
 
             if ($offering) {
-                $lineItem->salesTaxes()->sync($offering->salesTaxes->pluck('id')->toArray());
-                $lineItem->salesDiscounts()->sync($offering->salesDiscounts->pluck('id')->toArray());
+                $lineItem->adjustments()->syncWithoutDetaching($offering->purchaseTaxes->pluck('id')->toArray());
+                $lineItem->adjustments()->syncWithoutDetaching($offering->purchaseDiscounts->pluck('id')->toArray());
             }
 
             $lineItem->refresh();

database/factories/Accounting/InvoiceFactory.php

 
     public function withLineItems(int $count = 3): self
     {
-        return $this->has(DocumentLineItem::factory()->count($count), 'lineItems');
+        return $this->has(DocumentLineItem::factory()->forInvoice()->count($count), 'lineItems');
     }
 
     public function approved(): static
             if ($invoiceStatus === InvoiceStatus::Paid) {
                 $latestPaymentDate = max($paymentDates);
                 $invoice->updateQuietly([
-                    'status' => InvoiceStatus::Paid,
+                    'status' => $invoiceStatus,
                     'paid_at' => $latestPaymentDate,
                 ]);
             }

database/factories/CompanyFactory.php

 
 namespace Database\Factories;
 
+use App\Enums\Accounting\BillStatus;
 use App\Enums\Accounting\InvoiceStatus;
+use App\Models\Accounting\Bill;
 use App\Models\Accounting\Invoice;
 use App\Models\Accounting\Transaction;
 use App\Models\Common\Client;
                 ]);
         });
     }
+
+    public function withBills(int $count = 10): self
+    {
+        return $this->afterCreating(function (Company $company) use ($count) {
+            $unpaidCount = (int) floor($count * 0.4);
+            $paidCount = (int) floor($count * 0.4);
+            $partialCount = $count - ($unpaidCount + $paidCount);
+
+            // Create unpaid bills
+            Bill::factory()
+                ->count($unpaidCount)
+                ->withLineItems()
+                ->initialized()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            // Create paid bills
+            Bill::factory()
+                ->count($paidCount)
+                ->withLineItems()
+                ->initialized()
+                ->withPayments(max: 4)
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            // Create partially paid bills
+            Bill::factory()
+                ->count($partialCount)
+                ->withLineItems()
+                ->initialized()
+                ->withPayments(max: 4, billStatus: BillStatus::Partial)
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+        });
+    }
 }

database/migrations/2024_11_27_221657_create_bills_table.php

             $table->string('order_number')->nullable(); // PO, SO, etc.
             $table->date('date')->nullable();
             $table->date('due_date')->nullable();
+            $table->timestamp('paid_at')->nullable();
             $table->string('status')->default('unpaid');
             $table->string('currency_code')->nullable();
             $table->integer('subtotal')->default(0);
             $table->integer('total')->default(0);
             $table->integer('amount_paid')->default(0);
             $table->integer('amount_due')->storedAs('total - amount_paid');
+            $table->text('notes')->nullable();
             $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
             $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamps();

database/seeders/DatabaseSeeder.php

                     ->withOfferings()
                     ->withClients()
                     ->withVendors()
-                    ->withInvoices(50);
+                    ->withInvoices(50)
+                    ->withBills(50);
             })
             ->create([
                 'name' => 'Admin',

package-lock.json

             }
         },
         "node_modules/@rollup/rollup-android-arm-eabi": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.28.0.tgz",
-            "integrity": "sha512-wLJuPLT6grGZsy34g4N1yRfYeouklTgPhH1gWXCYspenKYD0s3cR99ZevOGw5BexMNywkbV3UkjADisozBmpPQ==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.28.1.tgz",
+            "integrity": "sha512-2aZp8AES04KI2dy3Ss6/MDjXbwBzj+i0GqKtWXgw2/Ma6E4jJvujryO6gJAghIRVz7Vwr9Gtl/8na3nDUKpraQ==",
             "cpu": [
                 "arm"
             ],
             ]
         },
         "node_modules/@rollup/rollup-android-arm64": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.28.0.tgz",
-            "integrity": "sha512-eiNkznlo0dLmVG/6wf+Ifi/v78G4d4QxRhuUl+s8EWZpDewgk7PX3ZyECUXU0Zq/Ca+8nU8cQpNC4Xgn2gFNDA==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.28.1.tgz",
+            "integrity": "sha512-EbkK285O+1YMrg57xVA+Dp0tDBRB93/BZKph9XhMjezf6F4TpYjaUSuPt5J0fZXlSag0LmZAsTmdGGqPp4pQFA==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-darwin-arm64": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.28.0.tgz",
-            "integrity": "sha512-lmKx9yHsppblnLQZOGxdO66gT77bvdBtr/0P+TPOseowE7D9AJoBw8ZDULRasXRWf1Z86/gcOdpBrV6VDUY36Q==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.28.1.tgz",
+            "integrity": "sha512-prduvrMKU6NzMq6nxzQw445zXgaDBbMQvmKSJaxpaZ5R1QDM8w+eGxo6Y/jhT/cLoCvnZI42oEqf9KQNYz1fqQ==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-darwin-x64": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.28.0.tgz",
-            "integrity": "sha512-8hxgfReVs7k9Js1uAIhS6zq3I+wKQETInnWQtgzt8JfGx51R1N6DRVy3F4o0lQwumbErRz52YqwjfvuwRxGv1w==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.28.1.tgz",
+            "integrity": "sha512-WsvbOunsUk0wccO/TV4o7IKgloJ942hVFK1CLatwv6TJspcCZb9umQkPdvB7FihmdxgaKR5JyxDjWpCOp4uZlQ==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-freebsd-arm64": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.28.0.tgz",
-            "integrity": "sha512-lA1zZB3bFx5oxu9fYud4+g1mt+lYXCoch0M0V/xhqLoGatbzVse0wlSQ1UYOWKpuSu3gyN4qEc0Dxf/DII1bhQ==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.28.1.tgz",
+            "integrity": "sha512-HTDPdY1caUcU4qK23FeeGxCdJF64cKkqajU0iBnTVxS8F7H/7BewvYoG+va1KPSL63kQ1PGNyiwKOfReavzvNA==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-freebsd-x64": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.28.0.tgz",
-            "integrity": "sha512-aI2plavbUDjCQB/sRbeUZWX9qp12GfYkYSJOrdYTL/C5D53bsE2/nBPuoiJKoWp5SN78v2Vr8ZPnB+/VbQ2pFA==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.28.1.tgz",
+            "integrity": "sha512-m/uYasxkUevcFTeRSM9TeLyPe2QDuqtjkeoTpP9SW0XxUWfcYrGDMkO/m2tTw+4NMAF9P2fU3Mw4ahNvo7QmsQ==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.28.0.tgz",
-            "integrity": "sha512-WXveUPKtfqtaNvpf0iOb0M6xC64GzUX/OowbqfiCSXTdi/jLlOmH0Ba94/OkiY2yTGTwteo4/dsHRfh5bDCZ+w==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.28.1.tgz",
+            "integrity": "sha512-QAg11ZIt6mcmzpNE6JZBpKfJaKkqTm1A9+y9O+frdZJEuhQxiugM05gnCWiANHj4RmbgeVJpTdmKRmH/a+0QbA==",
             "cpu": [
                 "arm"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.28.0.tgz",
-            "integrity": "sha512-yLc3O2NtOQR67lI79zsSc7lk31xjwcaocvdD1twL64PK1yNaIqCeWI9L5B4MFPAVGEVjH5k1oWSGuYX1Wutxpg==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.28.1.tgz",
+            "integrity": "sha512-dRP9PEBfolq1dmMcFqbEPSd9VlRuVWEGSmbxVEfiq2cs2jlZAl0YNxFzAQS2OrQmsLBLAATDMb3Z6MFv5vOcXg==",
             "cpu": [
                 "arm"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm64-gnu": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.28.0.tgz",
-            "integrity": "sha512-+P9G9hjEpHucHRXqesY+3X9hD2wh0iNnJXX/QhS/J5vTdG6VhNYMxJ2rJkQOxRUd17u5mbMLHM7yWGZdAASfcg==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.28.1.tgz",
+            "integrity": "sha512-uGr8khxO+CKT4XU8ZUH1TTEUtlktK6Kgtv0+6bIFSeiSlnGJHG1tSFSjm41uQ9sAO/5ULx9mWOz70jYLyv1QkA==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-arm64-musl": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.28.0.tgz",
-            "integrity": "sha512-1xsm2rCKSTpKzi5/ypT5wfc+4bOGa/9yI/eaOLW0oMs7qpC542APWhl4A37AENGZ6St6GBMWhCCMM6tXgTIplw==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.28.1.tgz",
+            "integrity": "sha512-QF54q8MYGAqMLrX2t7tNpi01nvq5RI59UBNx+3+37zoKX5KViPo/gk2QLhsuqok05sSCRluj0D00LzCwBikb0A==",
             "cpu": [
                 "arm64"
             ],
                 "linux"
             ]
         },
+        "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.28.1.tgz",
+            "integrity": "sha512-vPul4uodvWvLhRco2w0GcyZcdyBfpfDRgNKU+p35AWEbJ/HPs1tOUrkSueVbBS0RQHAf/A+nNtDpvw95PeVKOA==",
+            "cpu": [
+                "loong64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
         "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.28.0.tgz",
-            "integrity": "sha512-zgWxMq8neVQeXL+ouSf6S7DoNeo6EPgi1eeqHXVKQxqPy1B2NvTbaOUWPn/7CfMKL7xvhV0/+fq/Z/J69g1WAQ==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.28.1.tgz",
+            "integrity": "sha512-pTnTdBuC2+pt1Rmm2SV7JWRqzhYpEILML4PKODqLz+C7Ou2apEV52h19CR7es+u04KlqplggmN9sqZlekg3R1A==",
             "cpu": [
                 "ppc64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.28.0.tgz",
-            "integrity": "sha512-VEdVYacLniRxbRJLNtzwGt5vwS0ycYshofI7cWAfj7Vg5asqj+pt+Q6x4n+AONSZW/kVm+5nklde0qs2EUwU2g==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.28.1.tgz",
+            "integrity": "sha512-vWXy1Nfg7TPBSuAncfInmAI/WZDd5vOklyLJDdIRKABcZWojNDY0NJwruY2AcnCLnRJKSaBgf/GiJfauu8cQZA==",
             "cpu": [
                 "riscv64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-s390x-gnu": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.28.0.tgz",
-            "integrity": "sha512-LQlP5t2hcDJh8HV8RELD9/xlYtEzJkm/aWGsauvdO2ulfl3QYRjqrKW+mGAIWP5kdNCBheqqqYIGElSRCaXfpw==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.28.1.tgz",
+            "integrity": "sha512-/yqC2Y53oZjb0yz8PVuGOQQNOTwxcizudunl/tFs1aLvObTclTwZ0JhXF2XcPT/zuaymemCDSuuUPXJJyqeDOg==",
             "cpu": [
                 "s390x"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-x64-gnu": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.28.0.tgz",
-            "integrity": "sha512-Nl4KIzteVEKE9BdAvYoTkW19pa7LR/RBrT6F1dJCV/3pbjwDcaOq+edkP0LXuJ9kflW/xOK414X78r+K84+msw==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.28.1.tgz",
+            "integrity": "sha512-fzgeABz7rrAlKYB0y2kSEiURrI0691CSL0+KXwKwhxvj92VULEDQLpBYLHpF49MSiPG4sq5CK3qHMnb9tlCjBw==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-linux-x64-musl": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.28.0.tgz",
-            "integrity": "sha512-eKpJr4vBDOi4goT75MvW+0dXcNUqisK4jvibY9vDdlgLx+yekxSm55StsHbxUsRxSTt3JEQvlr3cGDkzcSP8bw==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.28.1.tgz",
+            "integrity": "sha512-xQTDVzSGiMlSshpJCtudbWyRfLaNiVPXt1WgdWTwWz9n0U12cI2ZVtWe/Jgwyv/6wjL7b66uu61Vg0POWVfz4g==",
             "cpu": [
                 "x64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-win32-arm64-msvc": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.28.0.tgz",
-            "integrity": "sha512-Vi+WR62xWGsE/Oj+mD0FNAPY2MEox3cfyG0zLpotZdehPFXwz6lypkGs5y38Jd/NVSbOD02aVad6q6QYF7i8Bg==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.28.1.tgz",
+            "integrity": "sha512-wSXmDRVupJstFP7elGMgv+2HqXelQhuNf+IS4V+nUpNVi/GUiBgDmfwD0UGN3pcAnWsgKG3I52wMOBnk1VHr/A==",
             "cpu": [
                 "arm64"
             ],
             ]
         },
         "node_modules/@rollup/rollup-win32-ia32-msvc": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.28.0.tgz",
-            "integrity": "sha512-kN/Vpip8emMLn/eOza+4JwqDZBL6MPNpkdaEsgUtW1NYN3DZvZqSQrbKzJcTL6hd8YNmFTn7XGWMwccOcJBL0A==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.28.1.tgz",
+            "integrity": "sha512-ZkyTJ/9vkgrE/Rk9vhMXhf8l9D+eAhbAVbsGsXKy2ohmJaWg0LPQLnIxRdRp/bKyr8tXuPlXhIoGlEB5XpJnGA==",
             "cpu": [
                 "ia32"
             ],
             ]
         },
         "node_modules/@rollup/rollup-win32-x64-msvc": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.28.0.tgz",
-            "integrity": "sha512-Bvno2/aZT6usSa7lRDL2+hMjVAGjuqaymF1ApZm31JXzniR/hvr14jpU+/z4X6Gt5BPlzosscyJZGUvguXIqeQ==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.28.1.tgz",
+            "integrity": "sha512-ZvK2jBafvttJjoIdKm/Q/Bh7IJ1Ose9IBOwpOXcOvW3ikGTQGmKDgxTC6oCAzW6PynbkKP8+um1du81XJHZ0JA==",
             "cpu": [
                 "x64"
             ],
             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001686",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001686.tgz",
-            "integrity": "sha512-Y7deg0Aergpa24M3qLC5xjNklnKnhsmSyR/V89dLZ1n0ucJIFNs7PgR2Yfa/Zf6W79SbBicgtGxZr2juHkEUIA==",
+            "version": "1.0.30001687",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001687.tgz",
+            "integrity": "sha512-0S/FDhf4ZiqrTUiQ39dKeUjYRjkv7lOZU1Dgif2rIqrTzX/1wV2hfKu9TOm1IHkdSijfLswxTFzl/cvir+SLSQ==",
             "dev": true,
             "funding": [
                 {
             }
         },
         "node_modules/rollup": {
-            "version": "4.28.0",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.28.0.tgz",
-            "integrity": "sha512-G9GOrmgWHBma4YfCcX8PjH0qhXSdH8B4HDE2o4/jaxj93S4DPCIDoLcXz99eWMji4hB29UFCEd7B2gwGJDR9cQ==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.28.1.tgz",
+            "integrity": "sha512-61fXYl/qNVinKmGSTHAZ6Yy8I3YIJC/r2m9feHo6SwVAVcLT5MPwOUFe7EuURA/4m0NR8lXG4BBXuo/IZEsjMg==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "npm": ">=8.0.0"
             },
             "optionalDependencies": {
-                "@rollup/rollup-android-arm-eabi": "4.28.0",
-                "@rollup/rollup-android-arm64": "4.28.0",
-                "@rollup/rollup-darwin-arm64": "4.28.0",
-                "@rollup/rollup-darwin-x64": "4.28.0",
-                "@rollup/rollup-freebsd-arm64": "4.28.0",
-                "@rollup/rollup-freebsd-x64": "4.28.0",
-                "@rollup/rollup-linux-arm-gnueabihf": "4.28.0",
-                "@rollup/rollup-linux-arm-musleabihf": "4.28.0",
-                "@rollup/rollup-linux-arm64-gnu": "4.28.0",
-                "@rollup/rollup-linux-arm64-musl": "4.28.0",
-                "@rollup/rollup-linux-powerpc64le-gnu": "4.28.0",
-                "@rollup/rollup-linux-riscv64-gnu": "4.28.0",
-                "@rollup/rollup-linux-s390x-gnu": "4.28.0",
-                "@rollup/rollup-linux-x64-gnu": "4.28.0",
-                "@rollup/rollup-linux-x64-musl": "4.28.0",
-                "@rollup/rollup-win32-arm64-msvc": "4.28.0",
-                "@rollup/rollup-win32-ia32-msvc": "4.28.0",
-                "@rollup/rollup-win32-x64-msvc": "4.28.0",
+                "@rollup/rollup-android-arm-eabi": "4.28.1",
+                "@rollup/rollup-android-arm64": "4.28.1",
+                "@rollup/rollup-darwin-arm64": "4.28.1",
+                "@rollup/rollup-darwin-x64": "4.28.1",
+                "@rollup/rollup-freebsd-arm64": "4.28.1",
+                "@rollup/rollup-freebsd-x64": "4.28.1",
+                "@rollup/rollup-linux-arm-gnueabihf": "4.28.1",
+                "@rollup/rollup-linux-arm-musleabihf": "4.28.1",
+                "@rollup/rollup-linux-arm64-gnu": "4.28.1",
+                "@rollup/rollup-linux-arm64-musl": "4.28.1",
+                "@rollup/rollup-linux-loongarch64-gnu": "4.28.1",
+                "@rollup/rollup-linux-powerpc64le-gnu": "4.28.1",
+                "@rollup/rollup-linux-riscv64-gnu": "4.28.1",
+                "@rollup/rollup-linux-s390x-gnu": "4.28.1",
+                "@rollup/rollup-linux-x64-gnu": "4.28.1",
+                "@rollup/rollup-linux-x64-musl": "4.28.1",
+                "@rollup/rollup-win32-arm64-msvc": "4.28.1",
+                "@rollup/rollup-win32-ia32-msvc": "4.28.1",
+                "@rollup/rollup-win32-x64-msvc": "4.28.1",
                 "fsevents": "~2.3.2"
             }
         },

resources/views/filament/widgets/enhanced-stats-overview-widget/enhanced-stat.blade.php

+@php
+    use Filament\Support\Enums\IconPosition;
+    use Filament\Support\Facades\FilamentView;
+
+    $chartColor = $getChartColor() ?? 'gray';
+    $descriptionColor = $getDescriptionColor() ?? 'gray';
+    $descriptionIcon = $getDescriptionIcon();
+    $descriptionIconPosition = $getDescriptionIconPosition();
+    $url = $getUrl();
+    $tag = $url ? 'a' : 'div';
+    $dataChecksum = $generateDataChecksum();
+
+    $descriptionIconClasses = \Illuminate\Support\Arr::toCssClasses([
+        'fi-wi-stats-overview-stat-description-icon h-5 w-5',
+        match ($descriptionColor) {
+            'gray' => 'text-gray-400 dark:text-gray-500',
+            default => 'text-custom-500',
+        },
+    ]);
+
+    $descriptionIconStyles = \Illuminate\Support\Arr::toCssStyles([
+        \Filament\Support\get_color_css_variables(
+            $descriptionColor,
+            shades: [500],
+            alias: 'widgets::stats-overview-widget.stat.description.icon',
+        ) => $descriptionColor !== 'gray',
+    ]);
+
+    $prefixLabel = $getPrefixLabel();
+    $suffixLabel = $getSuffixLabel();
+@endphp
+
+<{!! $tag !!}
+    @if ($url)
+        {{ \Filament\Support\generate_href_html($url, $shouldOpenUrlInNewTab()) }}
+    @endif
+    {{
+        $getExtraAttributeBag()
+            ->class([
+                'fi-wi-stats-overview-stat relative rounded-xl bg-white p-6 shadow-sm ring-1 ring-gray-950/5 dark:bg-gray-900 dark:ring-white/10',
+            ])
+    }}
+>
+    <div class="grid gap-y-2">
+        <div class="flex items-center gap-x-2">
+            @if ($icon = $getIcon())
+                <x-filament::icon
+                    :icon="$icon"
+                    class="fi-wi-stats-overview-stat-icon h-5 w-5 text-gray-400 dark:text-gray-500"
+                />
+            @endif
+
+            <span
+                class="fi-wi-stats-overview-stat-label text-sm font-medium text-gray-500 dark:text-gray-400"
+            >
+                {{ $getLabel() }}
+            </span>
+        </div>
+
+        <div
+            class="fi-wi-stats-overview-stat-value text-2xl font-semibold tracking-tight text-gray-950 dark:text-white"
+        >
+            @if ($prefixLabel)
+                <span class="prefix-label text-base font-medium text-gray-500 dark:text-gray-400">
+                    {{ $prefixLabel }}
+                </span>
+            @endif
+
+            {{ $getValue() }}
+
+            @if ($suffixLabel)
+                <span class="suffix-label text-base font-medium text-gray-500 dark:text-gray-400">
+                    {{ $suffixLabel }}
+                </span>
+            @endif
+        </div>
+
+        @if ($description = $getDescription())
+            <div class="flex items-center gap-x-1">
+                @if ($descriptionIcon && in_array($descriptionIconPosition, [IconPosition::Before, 'before']))
+                    <x-filament::icon
+                        :icon="$descriptionIcon"
+                        :class="$descriptionIconClasses"
+                        :style="$descriptionIconStyles"
+                    />
+                @endif
+
+                <span
+                    @class([
+                        'fi-wi-stats-overview-stat-description text-sm',
+                        match ($descriptionColor) {
+                            'gray' => 'text-gray-500 dark:text-gray-400',
+                            default => 'fi-color-custom text-custom-600 dark:text-custom-400',
+                        },
+                        is_string($descriptionColor) ? "fi-color-{$descriptionColor}" : null,
+                    ])
+                    @style([
+                        \Filament\Support\get_color_css_variables(
+                            $descriptionColor,
+                            shades: [400, 600],
+                            alias: 'widgets::stats-overview-widget.stat.description',
+                        ) => $descriptionColor !== 'gray',
+                    ])
+                >
+                    {{ $description }}
+                </span>
+
+                @if ($descriptionIcon && in_array($descriptionIconPosition, [IconPosition::After, 'after']))
+                    <x-filament::icon
+                        :icon="$descriptionIcon"
+                        :class="$descriptionIconClasses"
+                        :style="$descriptionIconStyles"
+                    />
+                @endif
+            </div>
+        @endif
+    </div>
+
+    @if ($chart = $getChart())
+        {{-- An empty function to initialize the Alpine component with until it's loaded with `ax-load`. This removes the need for `x-ignore`, allowing the chart to be updated via Livewire polling. --}}
+        <div x-data="{ statsOverviewStatChart: function () {} }">
+            <div
+                @if (FilamentView::hasSpaMode())
+                    ax-load="visible"
+                @else
+                    ax-load
+                @endif
+                ax-load-src="{{ \Filament\Support\Facades\FilamentAsset::getAlpineComponentSrc('stats-overview/stat/chart', 'filament/widgets') }}"
+                x-data="statsOverviewStatChart({
+                            dataChecksum: @js($dataChecksum),
+                            labels: @js(array_keys($chart)),
+                            values: @js(array_values($chart)),
+                        })"
+                @class([
+                    'fi-wi-stats-overview-stat-chart absolute inset-x-0 bottom-0 overflow-hidden rounded-b-xl',
+                    match ($chartColor) {
+                        'gray' => null,
+                        default => 'fi-color-custom',
+                    },
+                    is_string($chartColor) ? "fi-color-{$chartColor}" : null,
+                ])
+                @style([
+                    \Filament\Support\get_color_css_variables(
+                        $chartColor,
+                        shades: [50, 400, 500],
+                        alias: 'widgets::stats-overview-widget.stat.chart',
+                    ) => $chartColor !== 'gray',
+                ])
+            >
+                <canvas x-ref="canvas" class="h-6"></canvas>
+
+                <span
+                    x-ref="backgroundColorElement"
+                    @class([
+                        match ($chartColor) {
+                            'gray' => 'text-gray-100 dark:text-gray-800',
+                            default => 'text-custom-50 dark:text-custom-400/10',
+                        },
+                    ])
+                ></span>
+
+                <span
+                    x-ref="borderColorElement"
+                    @class([
+                        match ($chartColor) {
+                            'gray' => 'text-gray-400',
+                            default => 'text-custom-500 dark:text-custom-400',
+                        },
+                    ])
+                ></span>
+            </div>
+        </div>
+    @endif
+</{!! $tag !!}>