@dainamite/billing 0.17.0 → 0.19.0

package/src/modules/billing/api/statements/route.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { BillingStatement } from '../../data/entities'
+import { billingEntityIds } from '../../data/entityIds'
+import { billingStatementListQuerySchema } from '../../data/validators'
+import {
+  createBillingCrudOpenApi,
+  createPagedListResponseSchema,
+} from '../openapi'
+
+/**
+ * `GET /api/billing/statements` — paged consumption statements (SPEC-002 P3).
+ * Filter by account, status, and a `period_end` window. `?id=` narrows to one
+ * row for the detail page. Generation goes through
+ * POST /api/billing/statements/generate.
+ */
+
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['billing.statement.view'] },
+}
+
+export const metadata = routeMetadata
+
+const billingStatementListItemSchema = z.object({
+  id: z.string().uuid(),
+  bill_account_id: z.string().uuid(),
+  bill_run_id: z.string().uuid().nullable(),
+  period_start: z.string(),
+  period_end: z.string(),
+  currency_code: z.string(),
+  opening_balance: z.string(),
+  total_topups: z.string(),
+  total_usage: z.string(),
+  total_recurring: z.string(),
+  total_adjustments: z.string(),
+  closing_balance: z.string(),
+  debit_breakdown: z.record(z.string(), z.unknown()).nullable(),
+  status: z.string(),
+  organization_id: z.string().uuid(),
+  tenant_id: z.string().uuid(),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: BillingStatement,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+  },
+  list: {
+    schema: billingStatementListQuerySchema,
+    entityId: billingEntityIds.statement,
+    fields: [
+      'id',
+      'bill_account_id',
+      'bill_run_id',
+      'period_start',
+      'period_end',
+      'currency_code',
+      'opening_balance',
+      'total_topups',
+      'total_usage',
+      'total_recurring',
+      'total_adjustments',
+      'closing_balance',
+      'debit_breakdown',
+      'status',
+      'organization_id',
+      'tenant_id',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      periodEnd: 'period_end',
+      periodStart: 'period_start',
+      createdAt: 'created_at',
+    },
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (typeof query.id === 'string' && query.id) {
+        filters.id = { $eq: query.id }
+      }
+      if (typeof query.billAccountId === 'string' && query.billAccountId) {
+        filters.bill_account_id = { $eq: query.billAccountId }
+      }
+      if (typeof query.status === 'string' && query.status) {
+        filters.status = { $eq: query.status }
+      }
+      if (query.periodEndFrom instanceof Date) {
+        filters.period_end = Object.assign(
+          (filters.period_end as Record<string, unknown>) ?? {},
+          { $gte: query.periodEndFrom },
+        )
+      }
+      if (query.periodEndTo instanceof Date) {
+        filters.period_end = Object.assign(
+          (filters.period_end as Record<string, unknown>) ?? {},
+          { $lte: query.periodEndTo },
+        )
+      }
+      return filters
+    },
+  },
+  actions: {},
+})
+
+export const GET = crud.GET
+
+export const openApi = createBillingCrudOpenApi({
+  resourceName: 'BillingStatement',
+  pluralName: 'BillingStatements',
+  querySchema: billingStatementListQuerySchema,
+  listResponseSchema: createPagedListResponseSchema(billingStatementListItemSchema),
+})

package/src/modules/billing/api/topups/route.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { withScopedPayload } from '@open-mercato/shared/lib/api/scoped'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { BillingTopup } from '../../data/entities'
+import { billingEntityIds } from '../../data/entityIds'
+import {
+  billingTopupCreateSchema,
+  billingTopupListQuerySchema,
+} from '../../data/validators'
+import {
+  createBillingCrudOpenApi,
+  createPagedListResponseSchema,
+} from '../openapi'
+
+/**
+ * `/api/billing/topups` — GET (list registered top-ups) + POST (initiate).
+ *
+ * The nested, spec-faithful `POST /api/billing/accounts/{id}/topups` is a thin
+ * wrapper that injects the path id as `billAccountId` and delegates here, so
+ * all the RBAC / command-bus / side-effect plumbing lives in one place.
+ */
+
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['billing.topup.view'] },
+  POST: { requireAuth: true, requireFeatures: ['billing.topup.create'] },
+}
+
+export const metadata = routeMetadata
+
+const billingTopupListItemSchema = z.object({
+  id: z.string().uuid(),
+  bill_account_id: z.string().uuid(),
+  status: z.string(),
+  amount: z.string(),
+  currency_code: z.string(),
+  provider_key: z.string(),
+  payment_id: z.string().uuid(),
+  gateway_transaction_id: z.string().uuid().nullable(),
+  transaction_id: z.string().uuid().nullable(),
+  receipt_invoice_id: z.string().uuid().nullable(),
+  source_ref: z.string().nullable(),
+  metadata: z.record(z.string(), z.unknown()).nullable(),
+  organization_id: z.string().uuid(),
+  tenant_id: z.string().uuid(),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+
+const topupCreateResponseSchema = z.object({
+  topupId: z.string().uuid(),
+  paymentId: z.string().uuid(),
+  status: z.string(),
+  transactionId: z.string().uuid().nullable(),
+  redirectUrl: z.string().nullable(),
+  clientSecret: z.string().nullable(),
+})
+
+const rawBodySchema = z.object({}).passthrough()
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: BillingTopup,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  list: {
+    schema: billingTopupListQuerySchema,
+    entityId: billingEntityIds.topup,
+    fields: [
+      'id',
+      'bill_account_id',
+      'status',
+      'amount',
+      'currency_code',
+      'provider_key',
+      'payment_id',
+      'gateway_transaction_id',
+      'transaction_id',
+      'receipt_invoice_id',
+      'source_ref',
+      'metadata',
+      'organization_id',
+      'tenant_id',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+      amount: 'amount',
+    },
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (typeof query.id === 'string' && query.id) {
+        filters.id = { $eq: query.id }
+      }
+      if (typeof query.billAccountId === 'string' && query.billAccountId) {
+        filters.bill_account_id = { $eq: query.billAccountId }
+      }
+      if (typeof query.status === 'string' && query.status) {
+        filters.status = { $eq: query.status }
+      }
+      if (typeof query.search === 'string' && /^[0-9a-fA-F-]{36}$/.test(query.search.trim())) {
+        filters.id = { $eq: query.search.trim() }
+      }
+      return filters
+    },
+  },
+  actions: {
+    create: {
+      commandId: 'billing.topups.create',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        const scoped = withScopedPayload(raw ?? {}, ctx, translate)
+        return billingTopupCreateSchema.parse(scoped)
+      },
+      response: ({ result }) => ({
+        topupId: result?.topupId ?? null,
+        paymentId: result?.paymentId ?? null,
+        status: result?.status ?? null,
+        transactionId: result?.transactionId ?? null,
+        redirectUrl: result?.redirectUrl ?? null,
+        clientSecret: result?.clientSecret ?? null,
+      }),
+      status: 201,
+    },
+  },
+})
+
+const { POST } = crud
+export { POST }
+export const GET = crud.GET
+
+export const openApi = createBillingCrudOpenApi({
+  resourceName: 'BillingTopup',
+  pluralName: 'BillingTopups',
+  querySchema: billingTopupListQuerySchema,
+  listResponseSchema: createPagedListResponseSchema(billingTopupListItemSchema),
+  create: {
+    schema: billingTopupCreateSchema,
+    responseSchema: topupCreateResponseSchema,
+    description:
+      'Registers a prepaid top-up (status=pending) and opens a payment ' +
+      'session via core/payment_gateways. The balance is credited only on ' +
+      '`payment_gateways.payment.captured` (the capture subscriber issues the ' +
+      'VAT receipt). Returns the topup id, the payment session redirect URL / ' +
+      'client secret, and the gateway transaction id.',
+  },
+})

package/src/modules/billing/api/transactions/adjust/route.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { withScopedPayload } from '@open-mercato/shared/lib/api/scoped'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { BillingAccountTransaction } from '../../../data/entities'
+import { billingEntityIds } from '../../../data/entityIds'
+import { billingTransactionAdjustSchema } from '../../../data/validators'
+import { createBillingCrudOpenApi } from '../../openapi'
+
+/**
+ * `POST /api/billing/transactions/adjust` (SPEC-002 P5) — manual balance
+ * credit/debit (`type='adjustment'`), audited with the operator's `user_id`.
+ */
+
+const routeMetadata = {
+  POST: { requireAuth: true, requireFeatures: ['billing.balance.adjust'] },
+}
+
+export const metadata = routeMetadata
+
+const adjustResponseSchema = z.object({
+  transactionId: z.string().uuid(),
+  balance: z.string(),
+  balanceStatus: z.enum(['ok', 'low', 'exhausted']),
+  deduplicated: z.boolean(),
+})
+
+const rawBodySchema = z.object({}).passthrough()
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: BillingAccountTransaction,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  list: {
+    schema: z.object({}).passthrough(),
+    entityId: billingEntityIds.transaction,
+    fields: ['id'],
+    buildFilters: async () => ({}),
+  },
+  actions: {
+    create: {
+      commandId: 'billing.transactions.adjust',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        const scoped = withScopedPayload(raw ?? {}, ctx, translate)
+        return billingTransactionAdjustSchema.parse(scoped)
+      },
+      response: ({ result }) => ({
+        transactionId: result?.transactionId ?? null,
+        balance: result?.balance ?? null,
+        balanceStatus: result?.balanceStatus ?? null,
+        deduplicated: Boolean(result?.deduplicated),
+      }),
+      status: 201,
+    },
+  },
+})
+
+export const POST = crud.POST
+
+export const openApi = createBillingCrudOpenApi({
+  resourceName: 'BillingBalanceAdjustment',
+  pluralName: 'BillingBalanceAdjustments',
+  querySchema: z.object({}).passthrough(),
+  listResponseSchema: z.object({ items: z.array(z.unknown()) }),
+  create: {
+    schema: billingTransactionAdjustSchema,
+    responseSchema: adjustResponseSchema,
+    description:
+      'Manually credits (amount > 0) or debits (amount < 0) a prepaid ' +
+      "account's balance. Audited with the operator's user id. Non-fiscal — " +
+      'no receipt is issued. Returns the new balance + status.',
+  },
+})

package/src/modules/billing/api/transactions/route.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { BillingAccountTransaction } from '../../data/entities'
+import { billingEntityIds } from '../../data/entityIds'
+import { billingTransactionListQuerySchema } from '../../data/validators'
+import {
+  createBillingCrudOpenApi,
+  createPagedListResponseSchema,
+} from '../openapi'
+
+/**
+ * `GET /api/billing/transactions` — paged, append-only balance ledger
+ * (SPEC-002). Filter by account, type, and a `created_at` window. The
+ * write path is the command bus (real-time consume, top-up capture, period
+ * close, manual adjustment) — there is no create/update/delete here.
+ */
+
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['billing.balance.view'] },
+}
+
+export const metadata = routeMetadata
+
+const billingTransactionListItemSchema = z.object({
+  id: z.string().uuid(),
+  bill_account_id: z.string().uuid(),
+  type: z.string(),
+  amount: z.string(),
+  currency_code: z.string(),
+  balance_after: z.string(),
+  usage_id: z.string().uuid().nullable(),
+  billing_item_id: z.string().uuid().nullable(),
+  topup_id: z.string().uuid().nullable(),
+  statement_id: z.string().uuid().nullable(),
+  description: z.string(),
+  source_ref: z.string().nullable(),
+  metadata: z.record(z.string(), z.unknown()).nullable(),
+  user_id: z.string().uuid().nullable(),
+  organization_id: z.string().uuid(),
+  tenant_id: z.string().uuid(),
+  created_at: z.string(),
+})
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: BillingAccountTransaction,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  list: {
+    schema: billingTransactionListQuerySchema,
+    entityId: billingEntityIds.transaction,
+    fields: [
+      'id',
+      'bill_account_id',
+      'type',
+      'amount',
+      'currency_code',
+      'balance_after',
+      'usage_id',
+      'billing_item_id',
+      'topup_id',
+      'statement_id',
+      'description',
+      'source_ref',
+      'metadata',
+      'user_id',
+      'organization_id',
+      'tenant_id',
+      'created_at',
+    ],
+    sortFieldMap: {
+      createdAt: 'created_at',
+    },
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (typeof query.id === 'string' && query.id) {
+        filters.id = { $eq: query.id }
+      }
+      if (typeof query.billAccountId === 'string' && query.billAccountId) {
+        filters.bill_account_id = { $eq: query.billAccountId }
+      }
+      if (typeof query.type === 'string' && query.type) {
+        filters.type = { $eq: query.type }
+      }
+      if (query.createdFrom instanceof Date) {
+        filters.created_at = Object.assign(
+          (filters.created_at as Record<string, unknown>) ?? {},
+          { $gte: query.createdFrom },
+        )
+      }
+      if (query.createdTo instanceof Date) {
+        filters.created_at = Object.assign(
+          (filters.created_at as Record<string, unknown>) ?? {},
+          { $lte: query.createdTo },
+        )
+      }
+      return filters
+    },
+  },
+  // Append-only — no create/update/delete on this surface. Manual
+  // adjustments go through POST /api/billing/transactions/adjust.
+  actions: {},
+})
+
+export const GET = crud.GET
+
+export const openApi = createBillingCrudOpenApi({
+  resourceName: 'BillingAccountTransaction',
+  pluralName: 'BillingAccountTransactions',
+  querySchema: billingTransactionListQuerySchema,
+  listResponseSchema: createPagedListResponseSchema(billingTransactionListItemSchema),
+})

package/src/modules/billing/api/usage/route.ts

@@ -46,6 +46,15 @@ const billingUsageListItemSchema = z.object({
 const usageCreateResponseSchema = z.object({
   id: z.string().uuid().nullable(),
   deduplicated: z.boolean(),
+  // Prepaid accounts (SPEC-002) get the real-time balance body. Absent for
+  // postpaid accounts (the legacy append-only response is unchanged).
+  ratedAmount: z.string().optional(),
+  currencyCode: z.string().optional(),
+  balance: z.string().optional(),
+  balanceStatus: z.enum(['ok', 'low', 'exhausted']).optional(),
+  creditStatus: z.enum(['within_limit', 'near_limit', 'over_limit']).optional(),
+  tierBreakdown: z.array(z.record(z.string(), z.unknown())).optional(),
+  warning: z.string().nullable().optional(),
 })
 
 const rawBodySchema = z.object({}).passthrough()
@@ -118,10 +127,27 @@ const crud = makeCrudRoute({
         const scoped = withScopedPayload(raw ?? {}, ctx, translate)
         return billingUsageCreateSchema.parse(scoped)
       },
-      response: ({ result }) => ({
-        id: result?.id ?? null,
-        deduplicated: Boolean(result?.deduplicated),
-      }),
+      response: ({ result }) => {
+        const base = {
+          id: result?.id ?? null,
+          deduplicated: Boolean(result?.deduplicated),
+        }
+        // Pass through the prepaid balance body when present (prepaid
+        // accounts only); postpaid responses keep the legacy 2-field shape.
+        if (result && 'balance' in result && result.balance !== undefined) {
+          return {
+            ...base,
+            ratedAmount: result.ratedAmount,
+            currencyCode: result.currencyCode,
+            balance: result.balance,
+            balanceStatus: result.balanceStatus,
+            creditStatus: result.creditStatus,
+            tierBreakdown: result.tierBreakdown ?? [],
+            warning: result.warning ?? null,
+          }
+        }
+        return base
+      },
       status: 200,
     },
     // Usage has no update or delete by design — see file header.
@@ -143,6 +169,11 @@ export const openApi = createBillingCrudOpenApi({
     description:
       'Ingests a pre-aggregated usage record. Idempotent via `sourceRef`. ' +
       'Usage records are immutable once persisted — to correct a mis-aggregation, ' +
-      "post a `one_time` Billing Item credit (the spec's refund model).",
+      "post a `one_time` Billing Item credit (the spec's refund model). " +
+      'For a PREPAID account (SPEC-002) the upload is rated synchronously, ' +
+      'debited from the balance, and the response carries `ratedAmount`, the ' +
+      'remaining `balance`, `balanceStatus` (ok/low/exhausted), `creditStatus`, ' +
+      'and the `tierBreakdown`. Usage is never rejected — the balance may go ' +
+      'negative and the client is expected to throttle itself.',
   },
 })

package/src/modules/billing/backend/billing/accounts/[id]/page.tsx

@@ -20,6 +20,7 @@ import {
 import { normalizeCrudServerError } from '@open-mercato/ui/backend/utils/serverErrors'
 import { AccountForm, type AccountFormValues } from '../../../../components/AccountForm'
 import { DetailCard, DetailField } from '../../../../components/DetailFields'
+import { PrepaidPanel } from '../../../../components/PrepaidPanel'
 
 /**
  * `/backend/billing/accounts/[id]` — Billing Account detail.
@@ -54,6 +55,8 @@ type AccountRow = {
   } | null
   next_bill_date: string
   last_bill_date: string | null
+  billing_mode: 'postpaid' | 'prepaid'
+  credit_limit: string
   is_active: boolean
   created_at: string
   updated_at: string
@@ -108,6 +111,11 @@ function toFormValues(row: AccountRow): AccountFormValues {
     },
     nextBillDate: row.next_bill_date?.slice(0, 10) ?? '',
     isActive: row.is_active,
+    billingMode: row.billing_mode,
+    creditLimit: row.credit_limit ?? '0',
+    // The threshold lives on the balance row, not the account row — blank
+    // means "leave unchanged" on save.
+    lowBalanceThreshold: '',
   }
 }
 
@@ -135,6 +143,16 @@ function AccountView({ row }: { row: AccountRow }) {
       <DetailField label={t('billing.accounts.columns.currency', 'Currency')}>
         {row.currency_code}
       </DetailField>
+      <DetailField label={t('billing.accounts.columns.mode', 'Mode')}>
+        {row.billing_mode === 'prepaid' ? (
+          <Tag variant="brand">{t('billing.mode.prepaid', 'Prepaid')}</Tag>
+        ) : (
+          <Tag variant="neutral">{t('billing.mode.postpaid', 'Postpaid')}</Tag>
+        )}
+      </DetailField>
+      <DetailField label={t('billing.accounts.columns.credit_limit', 'Credit limit')}>
+        <span className="font-mono tabular-nums">{row.credit_limit}</span>
+      </DetailField>
       <DetailField label={t('billing.common.id', 'ID')}>
         <span className="font-mono text-xs">{row.id}</span>
       </DetailField>
@@ -425,6 +443,13 @@ export default function BillingAccountDetailPage(props: { params?: { id?: string
           isActive: values.isActive,
         }
         payload.taxId = values.taxId.trim() === '' ? null : values.taxId.trim()
+        // billingMode is immutable on update; creditLimit + threshold are editable.
+        const creditLimit = Number.parseFloat(values.creditLimit)
+        if (Number.isFinite(creditLimit) && creditLimit >= 0) payload.creditLimit = creditLimit
+        if (row.billing_mode === 'prepaid' && values.lowBalanceThreshold.trim()) {
+          const threshold = Number.parseFloat(values.lowBalanceThreshold)
+          if (Number.isFinite(threshold) && threshold >= 0) payload.lowBalanceThreshold = threshold
+        }
 
         await apiCallOrThrow('/api/billing/accounts', {
           method: 'PUT',
@@ -565,6 +590,9 @@ export default function BillingAccountDetailPage(props: { params?: { id?: string
         ) : (
           <AccountView row={row} />
         )}
+        {row.billing_mode === 'prepaid' ? (
+          <PrepaidPanel accountId={row.id} currencyCode={row.currency_code} />
+        ) : null}
         <AccountItemsSection accountId={row.id} />
         <AccountUsageSection accountId={row.id} />
         {ConfirmDialogElement}

package/src/modules/billing/backend/billing/accounts/create/page.tsx

@@ -43,8 +43,15 @@ export default function CreateBillingAccountPage() {
             country: values.invoiceAddress.country.trim().toUpperCase(),
           },
           nextBillDate: values.nextBillDate,
+          billingMode: values.billingMode,
         }
         if (values.taxId.trim()) payload.taxId = values.taxId.trim()
+        const creditLimit = Number.parseFloat(values.creditLimit)
+        if (Number.isFinite(creditLimit) && creditLimit >= 0) payload.creditLimit = creditLimit
+        if (values.billingMode === 'prepaid' && values.lowBalanceThreshold.trim()) {
+          const threshold = Number.parseFloat(values.lowBalanceThreshold)
+          if (Number.isFinite(threshold) && threshold >= 0) payload.lowBalanceThreshold = threshold
+        }
 
         const call = await apiCallOrThrow<{ id: string }>('/api/billing/accounts', {
           method: 'POST',

package/src/modules/billing/backend/billing/accounts/page.tsx

@@ -32,6 +32,7 @@ type BillingAccountRow = {
   invoice_email: string
   next_bill_date: string
   last_bill_date: string | null
+  billing_mode: 'postpaid' | 'prepaid'
   is_active: boolean
   created_at: string
 }
@@ -78,6 +79,15 @@ export default function BillingAccountsListPage() {
         label: t('billing.accounts.filters.currency', 'Currency'),
         type: 'text',
       },
+      {
+        id: 'billingMode',
+        label: t('billing.accounts.columns.mode', 'Mode'),
+        type: 'select',
+        options: [
+          { value: 'postpaid', label: t('billing.mode.postpaid', 'Postpaid') },
+          { value: 'prepaid', label: t('billing.mode.prepaid', 'Prepaid') },
+        ],
+      },
       {
         id: 'isActive',
         label: t('billing.accounts.filters.active', 'Active'),
@@ -107,6 +117,9 @@ export default function BillingAccountsListPage() {
       if (typeof filters.currencyCode === 'string' && filters.currencyCode.trim()) {
         params.set('currencyCode', filters.currencyCode.trim().toUpperCase())
       }
+      if (typeof filters.billingMode === 'string' && filters.billingMode) {
+        params.set('billingMode', filters.billingMode)
+      }
       if (filters.isActive === 'true') params.set('isActive', 'true')
       if (filters.isActive === 'false') params.set('isActive', 'false')
       const result = await readApiResultOrThrow<ListResponse>(
@@ -118,7 +131,15 @@ export default function BillingAccountsListPage() {
     } finally {
       setLoading(false)
     }
-  }, [filters.billCycle, filters.currencyCode, filters.isActive, page, pageSize, search])
+  }, [
+    filters.billCycle,
+    filters.currencyCode,
+    filters.billingMode,
+    filters.isActive,
+    page,
+    pageSize,
+    search,
+  ])
 
   React.useEffect(() => {
     void loadRows()
@@ -154,6 +175,16 @@ export default function BillingAccountsListPage() {
           </span>
         ),
       },
+      {
+        accessorKey: 'billing_mode',
+        header: t('billing.accounts.columns.mode', 'Mode'),
+        cell: ({ row }) =>
+          row.original.billing_mode === 'prepaid' ? (
+            <Tag variant="brand">{t('billing.mode.prepaid', 'Prepaid')}</Tag>
+          ) : (
+            <Tag variant="neutral">{t('billing.mode.postpaid', 'Postpaid')}</Tag>
+          ),
+      },
       {
         accessorKey: 'next_bill_date',
         header: t('billing.accounts.columns.next_bill', 'Next bill'),