shutro-erp 0.3.6 → 0.3.7

package/dist/accounting/index.js

@@ -12,8 +12,10 @@
  * (`shutro-erp/accounting/web`).
  */
 import { contacts } from '../contacts/index.js';
+import { mailerFromEnv } from '../mail/index.js';
 import { messaging } from '../messaging/index.js';
 import { defineModule } from '../modules-sdk/index.js';
+import { messengerFromEnv } from '../notify/index.js';
 import { permissions } from '../permissions/index.js';
 import { product } from '../product/index.js';
 import { reporting } from '../reporting/index.js';
@@ -22,12 +24,17 @@ import { action, field, form, hierarchy, list, pivot, search, stat } from '../vi
 import { ChartInstalledError, chartsOf, installChart, installedChart, installImmutability, installLocalization, localizationsOf, } from './chart.js';
 import { agingReport, closeFiscalYear, readSettings, reopenFiscalYear, updateSettings, } from './closing.js';
 import { accountingDemo } from './demo.js';
+import { AccountFiscalPosition, previewMove } from './fiscal.js';
+import { AccountFollowupLevel, AccountFollowupSent, configureFollowups, followUp, followupRows, installFollowupLevels, pauseFollowup, runFollowups, } from './followups.js';
 import { AccountAccount, AccountAnalytic, AccountFiscalYear, AccountJournal, AccountMove, AccountMoveLine, AccountPayment, AccountPaymentTerm, AccountWithholding, accountingShutro, REVERSED_KIND, ResBankAccount, ResCurrencyRate, } from './module.js';
 import { openLines, proposeWithholdings, reconcile, registerPayment, unreconcile, } from './payments.js';
+import { AccountBankStatement, AccountReconcileRule, applyRules, dryRunRule, importStatement, matchLine, parseCamt, parseCsv, parseOfx, proposalsFor, pullFeed, undoLine, writeOffLine, } from './statements.js';
 export { CHARTS, ChartInstalledError, COMMON_ACCOUNTS, chartsOf, DEFAULT_ACCOUNTS, installChart, installedChart, installImmutability, installLocalization, localizationsOf, } from './chart.js';
 export { agingReport, closeFiscalYear, readSettings, reopenFiscalYear, updateSettings, } from './closing.js';
+export { configureFollowups, followUp, followupRows, overdueCustomers, pauseFollowup, runFollowups, salesStopped, } from './followups.js';
 export { ACCOUNT_TYPES, AccountAccount, AccountAnalytic, AccountFiscalYear, AccountFullReconcile, AccountJournal, AccountMove, AccountMoveLine, AccountPartialReconcile, AccountPayment, AccountPaymentTerm, AccountPaymentTermLine, AccountPaymentWithholding, AccountTaxComponent, AccountWithholding, accountingShutro, addDays, CompanyAccounting, fiscalYearOf, isRefund, JOURNAL_TYPES, MOVE_KINDS, NUMBER_FIELD, owedToUs, PartnerWithholdings, REVERSED_KIND, ResBankAccount, ResCurrencyRate, supplyScope, TaxAccounts, } from './module.js';
 export { openLines, proposeWithholdings, reconcile, registerPayment, unreconcile, } from './payments.js';
+export { AccountReconcileRule, applyRules, bankFeed, dryRunRule, importStatement, matchLine, parseCamt, parseCsv, parseOfx, proposalsFor, pullFeed, registerBankFeed, testBankFeed, undoLine, writeOffLine, } from './statements.js';
 /**
  * Reverses a posted entry: a new entry in the same journal with every line negated, linked both ways, posted when
  * asked. The original is never touched beyond its `reversedBy` link.
@@ -109,6 +116,51 @@ export const accounting = defineModule({
     // Exceptions to the module standard (RFC 0023), each with its reason.
     standard: {
         waive: [
+            {
+                rule: 'I1',
+                model: 'account.bank.statement',
+                reason: 'Imported by its own CSV / OFX / CAMT import (Accounting › Reconcile bank), or pulled from a feed.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.fiscal.position',
+                reason: 'A few per company, set up on screen with their mappings.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.fiscal.position.tax',
+                reason: 'Lines of a fiscal position, edited on its form.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.fiscal.position.account',
+                reason: 'Lines of a fiscal position, edited on its form.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.followup.level',
+                reason: 'Three per company to start with, set up on screen.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.followup',
+                reason: 'Kept by the follow-up run and the Follow-ups screen, never imported.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.followup.sent',
+                reason: 'A log written when a reminder is sent.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.reconcile.rule',
+                reason: 'A handful per company, set up on screen with its dry run.',
+            },
+            {
+                rule: 'I1',
+                model: 'account.full.reconcile',
+                reason: 'Made by reconciling, never imported.',
+            },
             {
                 rule: 'M3',
                 model: 'account.full.reconcile',
@@ -135,6 +187,8 @@ export const accounting = defineModule({
         category: 'Finance',
         summary: 'Invoices, bills, journals and entries posted in exact money',
     },
+    // Bangla for the labels it serves (RFC 0023 §3.1; `pnpm i18n:extract`).
+    i18n: { bn: () => import('./i18n/bn.js') },
     accessLevels: {
         invoicing: { label: 'Invoicing (invoices and their payments)', groups: ['account.invoicing'] },
         user: {
@@ -381,12 +435,45 @@ export const accounting = defineModule({
             page: 'accounting.Reconcile',
             label: 'Reconciliation',
         },
+        'accounting.action_bank_reconcile': {
+            type: 'client',
+            page: 'accounting.BankReconcile',
+            label: 'Reconcile bank',
+            visibleTo: ['account.reconcile'],
+        },
+        'accounting.action_followups': {
+            type: 'client',
+            page: 'accounting.Followups',
+            label: 'Follow-ups',
+            visibleTo: ['account.user'],
+        },
+        'accounting.action_fiscal_positions': action(AccountFiscalPosition, {
+            label: 'Fiscal positions',
+            views: ['list', 'form'],
+        }),
+        'accounting.action_followup_levels': action(AccountFollowupLevel, {
+            label: 'Follow-up levels',
+            views: ['list', 'form'],
+        }),
+        'accounting.action_followup_sent': action(AccountFollowupSent, {
+            label: 'Reminders sent',
+            views: ['list'],
+        }),
+        'accounting.action_statements': {
+            model: 'account.bank.statement',
+            label: 'Bank statements',
+            views: ['list', 'form'],
+        },
         'accounting.action_settings': {
             type: 'client',
             page: 'accounting.Settings',
             label: 'Settings',
             visibleTo: ['account.manager'],
         },
+        'accounting.action_reconcile_rules': action(AccountReconcileRule, {
+            label: 'Reconciliation rules',
+            views: ['list', 'form'],
+        }),
         'accounting.action_payment_terms': action(AccountPaymentTerm, {
             label: 'Payment terms',
             views: ['list', 'form'],
@@ -463,6 +550,50 @@ export const accounting = defineModule({
             action: 'accounting.action_reconcile',
             sequence: 5,
         },
+        {
+            id: 'accounting.bank_reconcile',
+            parent: 'accounting.root',
+            label: 'Reconcile bank',
+            action: 'accounting.action_bank_reconcile',
+            sequence: 4.5,
+            visibleTo: ['account.reconcile'],
+        },
+        {
+            id: 'accounting.followups',
+            parent: 'accounting.root',
+            label: 'Follow-ups',
+            action: 'accounting.action_followups',
+            sequence: 4.7,
+            visibleTo: ['account.user'],
+        },
+        {
+            id: 'accounting.fiscal_positions',
+            parent: 'accounting.configuration',
+            label: 'Fiscal positions',
+            action: 'accounting.action_fiscal_positions',
+            sequence: 8,
+        },
+        {
+            id: 'accounting.followup_levels',
+            parent: 'accounting.configuration',
+            label: 'Follow-up levels',
+            action: 'accounting.action_followup_levels',
+            sequence: 7,
+        },
+        {
+            id: 'accounting.followup_sent',
+            parent: 'accounting.reporting',
+            label: 'Reminders sent',
+            action: 'accounting.action_followup_sent',
+            sequence: 9,
+        },
+        {
+            id: 'accounting.statements',
+            parent: 'accounting.root',
+            label: 'Bank statements',
+            action: 'accounting.action_statements',
+            sequence: 4.6,
+        },
         { id: 'accounting.reporting', parent: 'accounting.root', label: 'Reporting', sequence: 8 },
         {
             id: 'accounting.trial_balance',
@@ -589,12 +720,129 @@ export const accounting = defineModule({
             action: 'accounting.action_payment_terms',
             sequence: 5,
         },
+        {
+            id: 'accounting.reconcile_rules',
+            parent: 'accounting.configuration',
+            label: 'Reconciliation rules',
+            action: 'accounting.action_reconcile_rules',
+            sequence: 6,
+        },
     ],
     // What webhooks may subscribe to besides record changes (RFC 0017 §5.3).
     events: [
+        {
+            topic: 'account.bank.statement.closed',
+            model: 'account.bank.statement',
+            label: 'Bank statement closed',
+        },
+        {
+            topic: 'account.fiscal.year.closed',
+            model: 'account.fiscal.year',
+            label: 'Fiscal year closed',
+        },
+        { topic: 'account.payment.posted', model: 'account.payment', label: 'Payment posted' },
         { topic: 'account.move.posted', model: 'account.move', label: 'Entry, invoice or bill posted' },
     ],
     importTemplates: [
+        {
+            key: 'account_withholding',
+            model: 'account.withholding',
+            label: 'Withholding',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Direction', field: 'direction' },
+                { header: 'Computed on', field: 'base' },
+                { header: 'Rate', field: 'rate' },
+                { header: 'Applies from (document total)', field: 'threshold' },
+                { header: 'Account', field: 'account' },
+            ],
+        },
+        {
+            key: 'account_account',
+            model: 'account.account',
+            label: 'Account',
+            columns: [
+                { header: 'Code', field: 'code' },
+                { header: 'Name', field: 'name' },
+                { header: 'Type', field: 'type' },
+                { header: 'Allow reconciliation', field: 'reconcile' },
+                { header: 'Account currency', field: 'currency' },
+                { header: 'Note', field: 'note' },
+            ],
+        },
+        {
+            key: 'account_journal',
+            model: 'account.journal',
+            label: 'Journal',
+            columns: [
+                { header: 'Code', field: 'code' },
+                { header: 'Name', field: 'name' },
+                { header: 'Type', field: 'type' },
+                { header: 'Default account', field: 'defaultAccount' },
+            ],
+        },
+        {
+            key: 'account_fiscal_year',
+            model: 'account.fiscal.year',
+            label: 'Fiscal year',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'From', field: 'dateFrom' },
+                { header: 'To', field: 'dateTo' },
+            ],
+        },
+        {
+            key: 'account_payment_term',
+            model: 'account.payment.term',
+            label: 'Payment term',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Shown on documents', field: 'note' },
+                { header: 'Lines › Days', field: 'lines.days' },
+                { header: 'Lines › Percent', field: 'lines.percent' },
+            ],
+        },
+        {
+            key: 'account_move',
+            model: 'account.move',
+            label: 'Journal entry',
+            columns: [
+                { header: 'Journal', field: 'journal' },
+                { header: 'Date', field: 'date' },
+                { header: 'Type', field: 'kind' },
+                { header: 'Partner', field: 'partner' },
+                { header: 'Reference', field: 'ref' },
+                { header: 'Currency', field: 'currency' },
+                { header: 'Rate', field: 'rate' },
+                { header: 'Notes', field: 'narration' },
+                { header: 'Due date', field: 'dateDue' },
+                { header: 'Payment terms', field: 'paymentTerm' },
+                { header: 'Source document', field: 'invoiceOrigin' },
+                { header: 'Place of supply', field: 'placeOfSupply' },
+                { header: 'Lines › Account', field: 'lines.account' },
+                { header: 'Lines › Partner', field: 'lines.partner' },
+                { header: 'Lines › Label', field: 'lines.name' },
+                { header: 'Lines › Due date', field: 'lines.dateMaturity' },
+                { header: 'Lines › Debit', field: 'lines.debit' },
+            ],
+        },
+        {
+            key: 'account_payment',
+            model: 'account.payment',
+            label: 'Payment',
+            columns: [
+                { header: 'Direction', field: 'kind' },
+                { header: 'Partner', field: 'partner' },
+                { header: 'Journal', field: 'journal' },
+                { header: 'Date', field: 'date' },
+                { header: 'Currency', field: 'currency' },
+                { header: 'Amount', field: 'amount' },
+                { header: 'Memo', field: 'memo' },
+                { header: 'Withholdings › Withholding', field: 'withholdings.withholding' },
+                { header: 'Withholdings › Base', field: 'withholdings.base' },
+                { header: 'Withholdings › Amount', field: 'withholdings.amount' },
+            ],
+        },
         {
             key: 'cost_centres',
             model: 'account.analytic',
@@ -707,11 +955,134 @@ export const accounting = defineModule({
         {
             view: 'res.partner.form',
             operations: [
-                { append: 'roles', nodes: [field({ field: 'withholdings', id: 'withholdings' })] },
+                {
+                    append: 'roles',
+                    nodes: [
+                        field({ field: 'withholdings', id: 'withholdings' }),
+                        field({ field: 'sendInvoicesByEmail', id: 'send_invoices_by_email' }),
+                        field({ field: 'fiscalPosition', id: 'partner_fiscal_position' }),
+                        field({ field: 'receivableAccount', id: 'partner_receivable_account' }),
+                        field({ field: 'payableAccount', id: 'partner_payable_account' }),
+                    ],
+                },
+            ],
+        },
+        {
+            view: 'product.product.form',
+            operations: [
+                {
+                    append: 'sell',
+                    nodes: [field({ field: 'incomeAccount', id: 'product_income_account' })],
+                },
+                {
+                    append: 'buy',
+                    nodes: [field({ field: 'expenseAccount', id: 'product_expense_account' })],
+                },
+            ],
+        },
+        {
+            view: 'product.category.form',
+            operations: [
+                {
+                    append: 'main',
+                    nodes: [
+                        field({ field: 'incomeAccount', id: 'category_income_account' }),
+                        field({ field: 'expenseAccount', id: 'category_expense_account' }),
+                    ],
+                },
             ],
         },
     ],
+    // Invoices and credit notes sent by email with their PDF (RFC 0029 §3.3).
+    mailTemplates: [
+        {
+            key: 'invoice',
+            name: 'Invoice',
+            model: 'account.move',
+            document: 'accounting.invoice',
+            subject: '{{company.name}}: {{kind}} {{name}}',
+            body: 'Dear {{partner.name}},\n\nPlease find attached {{kind}} {{name}} of {{amountTotal}}, due on {{dateDue}}.\n\nThank you for your business.\n\n{{company.name}}',
+            translations: {
+                bn_BD: {
+                    subject: '{{company.name}}: {{kind}} {{name}}',
+                    body: 'প্রিয় {{partner.name}},\n\n{{amountTotal}}-এর {{kind}} {{name}} সংযুক্ত করা হলো, পরিশোধের তারিখ {{dateDue}}।\n\nআপনার সঙ্গে ব্যবসার জন্য ধন্যবাদ।\n\n{{company.name}}',
+                },
+            },
+        },
+    ],
+    sendable: [
+        {
+            model: 'account.move',
+            template: 'accounting.invoice',
+            partner: 'partner',
+            when: { state: 'posted', kind: { in: ['out_invoice', 'out_refund'] } },
+            autoSend: { topic: 'account.move.posted', flag: 'sendInvoicesByEmail' },
+        },
+    ],
     documents: [
+        {
+            key: 'bank_statement',
+            name: 'Bank statement',
+            model: 'account.bank.statement',
+            layout: {
+                paper: 'A4',
+                header: '{{company.name}}',
+                footer: 'Page {{page}} of {{pages}}',
+                blocks: [
+                    { kind: 'heading', id: 'title', text: 'Bank statement {{name}}', level: 1 },
+                    {
+                        kind: 'fields',
+                        id: 'statement',
+                        items: [
+                            { label: 'Journal', bind: 'journal.name' },
+                            { label: 'Date', bind: 'date' },
+                            { label: 'Opening balance', bind: 'balanceStart' },
+                            { label: 'Closing balance', bind: 'balanceEnd' },
+                            { label: 'Status', bind: 'state' },
+                        ],
+                    },
+                    {
+                        kind: 'table',
+                        id: 'lines',
+                        bind: 'lines',
+                        columns: [
+                            { label: 'Date', bind: 'date' },
+                            { label: 'Label', bind: 'label' },
+                            { label: 'Reference', bind: 'reference' },
+                            { label: 'Partner', bind: 'partner.name' },
+                            { label: 'Amount', bind: 'amount', align: 'end', sum: true },
+                            { label: 'Status', bind: 'state' },
+                        ],
+                    },
+                ],
+            },
+        },
+        {
+            key: 'fiscal_year',
+            name: 'Fiscal year',
+            model: 'account.fiscal.year',
+            layout: {
+                paper: 'A4',
+                header: '{{company.name}}',
+                footer: 'Page {{page}} of {{pages}}',
+                blocks: [
+                    { kind: 'heading', id: 'title', text: 'Fiscal year {{name}}', level: 1 },
+                    {
+                        kind: 'fields',
+                        id: 'year',
+                        items: [
+                            { label: 'From', bind: 'dateFrom' },
+                            { label: 'To', bind: 'dateTo' },
+                            { label: 'Status', bind: 'state' },
+                            { label: 'Locked until', bind: 'lockDate' },
+                            { label: 'Closing entry', bind: 'closingMove.name' },
+                            { label: 'Reopened because', bind: 'reopenReason' },
+                        ],
+                    },
+                    { kind: 'signature', id: 'sign', labels: ['Prepared by', 'Approved by'] },
+                ],
+            },
+        },
         {
             key: 'withholding_certificate',
             name: 'Withholding certificate',
@@ -815,6 +1186,84 @@ export const accounting = defineModule({
         },
     ],
     views: {
+        'account.bank.statement.list': list(AccountBankStatement, {
+            columns: ['date', 'name', 'journal', 'balanceStart', 'balanceEnd', 'state'],
+        }),
+        'account.bank.statement.form': form(AccountBankStatement, (k) => ({
+            header: {
+                statusbar: 'state',
+                buttons: [
+                    k.button('close', { primary: true, label: 'Close' }),
+                    k.button('reopen', { label: 'Reopen' }),
+                ],
+            },
+            sheet: [
+                k.group('main', ['name', 'journal', 'date', 'balanceStart', 'balanceEnd'], {
+                    description: 'Match its lines in Accounting › Reconcile bank; it closes once every line is matched and the balances agree.',
+                }),
+                k.lines('lines', [
+                    { field: 'date', id: 'statement_line_date' },
+                    { field: 'label', id: 'statement_line_label' },
+                    { field: 'reference', id: 'statement_line_reference' },
+                    { field: 'partner', id: 'statement_line_partner' },
+                    { field: 'amount', id: 'statement_line_amount' },
+                    { field: 'state', id: 'statement_line_state' },
+                ]),
+            ],
+            chatter: true,
+        })),
+        'account.fiscal.position.list': list(AccountFiscalPosition, {
+            columns: ['sequence', 'name', 'autoApply', 'countries', 'states', 'vatRequired'],
+        }),
+        'account.fiscal.position.form': form(AccountFiscalPosition, (k) => ({
+            header: { buttons: [] },
+            sheet: [
+                k.group('main', ['name', 'sequence', 'company', 'note']),
+                k.group('when', ['autoApply', 'countries', 'states', 'vatRequired'], {
+                    label: 'Applies to',
+                    description: 'A document uses the position chosen on it, else its partner’s, else the first that applies by itself.',
+                }),
+                k.lines('taxes', [
+                    { field: 'taxSrc', id: 'map_tax_src' },
+                    { field: 'taxDest', id: 'map_tax_dest' },
+                ]),
+                k.lines('accounts', [
+                    { field: 'accountSrc', id: 'map_account_src' },
+                    { field: 'accountDest', id: 'map_account_dest' },
+                ]),
+            ],
+        })),
+        'account.followup.level.list': list(AccountFollowupLevel, {
+            columns: ['days', 'name', 'sendEmail', 'sendSms', 'sendWhatsapp', 'blockSales'],
+        }),
+        'account.followup.level.form': form(AccountFollowupLevel, (k) => ({
+            header: { buttons: [] },
+            sheet: [
+                k.group('main', ['name', 'days', 'company', 'blockSales'], {
+                    description: 'Each day, a late customer gets one reminder for the highest level their oldest overdue invoice reached.',
+                }),
+                k.group('how', ['sendEmail', 'sendSms', 'sendWhatsapp'], { label: 'Sent by' }),
+                k.group('text', ['subject', 'body', 'shortText'], { label: 'What it says', columns: 1 }),
+            ],
+        })),
+        'account.followup.sent.list': list(AccountFollowupSent, {
+            columns: ['createdAt', 'partner', 'level', 'amount', 'channels', 'automatic'],
+        }),
+        'account.reconcile.rule.list': list(AccountReconcileRule, {
+            columns: ['sequence', 'name', 'direction', 'labelContains', 'outcome', 'hits'],
+        }),
+        'account.reconcile.rule.form': form(AccountReconcileRule, (k) => ({
+            header: { buttons: [] },
+            sheet: [
+                k.group('main', ['name', 'sequence', 'company'], {
+                    description: 'Rules run in order on every imported line; the first that applies wins. Try one with its dry run from Reconcile bank.',
+                }),
+                k.group('when', ['journals', 'direction', 'labelContains', 'amountMin', 'amountMax', 'partner'], {
+                    label: 'When',
+                }),
+                k.group('then', ['outcome', 'writeOffAccount', 'writeOffLabel', 'hits'], { label: 'Then' }),
+            ],
+        })),
         'account.move.invoice.list': list(AccountMove, {
             columns: [
                 'name',
@@ -864,7 +1313,15 @@ export const accounting = defineModule({
                         tone: 'success',
                     },
                 ]),
-                k.group('party', ['partner', 'kind', 'invoiceOrigin', 'ref', 'debitOf', 'placeOfSupply']),
+                k.group('party', [
+                    'partner',
+                    'kind',
+                    'invoiceOrigin',
+                    'ref',
+                    'debitOf',
+                    'placeOfSupply',
+                    'fiscalPosition',
+                ]),
                 k.group('dates', ['date', 'dateDue', 'paymentTerm', 'journal']),
                 k.lines('lines', [
                     'product',
@@ -877,6 +1334,8 @@ export const accounting = defineModule({
                     'taxes',
                     'subtotal',
                 ], { readonlyWhen: { state: { ne: 'draft' } } }),
+                // What posting will do: each line's taxes and account after the fiscal position, and why (RFC 0029 §3.5).
+                k.component('posting_preview', 'accounting.PostingPreview'),
                 k.group('totals', [
                     'amountUntaxed',
                     'amountTax',
@@ -1124,7 +1583,24 @@ export const accounting = defineModule({
         })),
     },
     search: {
+        'account.bank.statement': search(AccountBankStatement, {
+            fields: ['name', 'journal.name'],
+            groupBy: ['journal', 'state'],
+        }),
         'account.payment.term': search(AccountPaymentTerm, { fields: ['name'] }),
+        'account.followup.level': search(AccountFollowupLevel, { fields: ['name'] }),
+        'account.fiscal.position': search(AccountFiscalPosition, {
+            fields: ['name', 'countries'],
+            groupBy: ['autoApply'],
+        }),
+        'account.followup.sent': search(AccountFollowupSent, {
+            fields: ['partner.name', 'amount'],
+            groupBy: ['partner', 'level'],
+        }),
+        'account.reconcile.rule': search(AccountReconcileRule, {
+            fields: ['name', 'labelContains'],
+            groupBy: ['outcome', 'direction'],
+        }),
         'account.journal': search(AccountJournal, { fields: ['name', 'code'], groupBy: ['type'] }),
         'account.fiscal.year': search(AccountFiscalYear, {
             fields: ['name'],
@@ -1229,11 +1705,88 @@ export const accounting = defineModule({
         // The immutability triggers, idempotent (with every seed and app install).
         defaults: async (env) => {
             await installImmutability(env);
+            // The follow-up levels a company starts with (RFC 0029 §3.4).
+            const company = Number(env.companyId);
+            if (Number.isSafeInteger(company) &&
+                company > 0 &&
+                (await env
+                    .model('res.company')
+                    .search({ where: { id: company } })).ids.length > 0)
+                await installFollowupLevels(env);
             return undefined;
         },
         demo: accountingDemo,
+        // The books are kept (RFC 0008 §5.4): with posted entries, Accounting is disabled, never removed with its data.
+        preUninstall: async (env) => {
+            const posted = await env
+                .model('account.move')
+                .search({ where: { state: 'posted' }, limit: 1 });
+            if (posted.ids.length > 0)
+                throw new Error('posted journal entries exist, and the books are kept for the legal retention period');
+        },
     },
     routes: (context) => {
+        // Payment follow-ups (RFC 0029 §3.4): reminders by email and texts, links to the portal when it is installed.
+        const portal = context.registry.loaded.modules.some((m) => m.name === 'account_portal');
+        configureFollowups({
+            mailer: mailerFromEnv(),
+            messenger: messengerFromEnv(),
+            portalUrl: portal
+                ? (process.env['KOSH_PORTAL_URL'] ?? 'http://localhost:5174').replace(/\/$/, '')
+                : null,
+        });
+        const partnerId = (params) => {
+            const id = Number(params.partner);
+            if (!Number.isSafeInteger(id) || id <= 0)
+                throw new HttpProblem(400, 'invalid-path', 'Invalid customer', 'A customer id.');
+            return id;
+        };
+        // What posting a draft would do (RFC 0029 §3.5).
+        context.app.get('/api/v1/accounting/moves/:id/preview', async (request) => {
+            const id = Number(request.params.id);
+            if (!Number.isSafeInteger(id) || id <= 0)
+                throw new HttpProblem(400, 'invalid-path', 'Invalid entry', 'An entry id.');
+            return request.env((env) => previewMove(env, id));
+        });
+        context.app.get('/api/v1/accounting/followups', async (request) => request.env(async (env) => ({ rows: await followupRows(env) })));
+        context.app.post('/api/v1/accounting/followups/:partner/send', async (request) => {
+            const partner = partnerId(request.params);
+            return request.env((env) => followUp(env, partner, { force: true }), {
+                write: true,
+            });
+        });
+        context.app.post('/api/v1/accounting/followups/:partner/pause', async (request) => {
+            const partner = partnerId(request.params);
+            const body = (request.body ?? {});
+            const until = body.until === null || body.until === undefined ? null : String(body.until);
+            const note = typeof body.note === 'string' && body.note.trim() !== '' ? body.note.trim() : null;
+            return request.env(async (env) => {
+                await pauseFollowup(env, partner, until, note);
+                return { partner, pausedUntil: until };
+            }, { write: true });
+        });
+        if (process.env['KOSH_SCHEDULES'] !== 'off') {
+            const run = async () => {
+                try {
+                    const companies = await context.shutro.bootstrap({ reason: 'payment follow-ups' }, async (env) => (await env.model('res.company').search({}))
+                        .ids);
+                    for (const company of companies)
+                        await context.shutro.bootstrap({ reason: 'payment follow-ups', company }, (env) => runFollowups(env));
+                }
+                catch (error) {
+                    context.app.log.error({ err: error }, 'payment follow-ups');
+                }
+            };
+            // Once a day (a run sends each level once, so a restart sending again finds nothing new).
+            const timer = setInterval(() => void run(), 86_400_000);
+            timer.unref();
+            const first = setTimeout(() => void run(), 60_000);
+            first.unref();
+            context.app.addHook('onClose', async () => {
+                clearInterval(timer);
+                clearTimeout(first);
+            });
+        }
         // The charts: the generic one and the installed localizations' (RFC 0016).
         const charts = chartsOf(context.registry.loaded.modules);
         const localizations = localizationsOf(context.registry.loaded.modules);
@@ -1313,6 +1866,100 @@ export const accounting = defineModule({
                 throw new HttpProblem(400, 'invalid-body', 'Invalid request', 'lines is a list of journal item ids.');
             return ids;
         };
+        // Bank statements (RFC 0029 §3.1): import, the proposals of a line, matching, writing off, pulling a feed.
+        const reconciler = (env) => {
+            if (!env.su && !env.administrator && !env.access.has('account.reconcile'))
+                throw new HttpProblem(403, 'access', 'Reconciliation', 'Bank statements need the reconcile permission.');
+        };
+        const positiveId = (value, what) => {
+            const id = Number(value);
+            if (!Number.isSafeInteger(id) || id <= 0)
+                throw new HttpProblem(400, 'invalid-body', 'Invalid request', `${what} is an id.`);
+            return id;
+        };
+        context.app.post('/api/v1/accounting/statements/import', async (request) => {
+            const body = (request.body ?? {});
+            const journal = positiveId(body.journal, 'journal');
+            const content = typeof body.content === 'string' ? body.content : '';
+            if (content === '' || content.length > 5_000_000)
+                throw new HttpProblem(400, 'invalid-body', 'Invalid request', 'content is the file’s text.');
+            const format = String(body.format ?? 'csv');
+            const rows = format === 'ofx'
+                ? parseOfx(content)
+                : format === 'camt'
+                    ? parseCamt(content)
+                    : format === 'csv'
+                        ? parseCsv(content, (body.mapping ?? {}))
+                        : null;
+            if (rows === null)
+                throw new HttpProblem(400, 'invalid-body', 'Invalid request', "format is 'csv', 'ofx' or 'camt'.");
+            const money = (v) => v === undefined || v === null || v === '' ? undefined : String(v);
+            return request.env(async (raw) => {
+                const env = raw;
+                reconciler(env);
+                const start = money(body.balanceStart);
+                const end = money(body.balanceEnd);
+                return importStatement(env, {
+                    journal,
+                    rows,
+                    ...(typeof body.name === 'string' && body.name !== '' ? { name: body.name } : {}),
+                    ...(start === undefined ? {} : { balanceStart: start }),
+                    ...(end === undefined ? {} : { balanceEnd: end }),
+                });
+            }, { write: true });
+        });
+        context.app.get('/api/v1/accounting/statement-lines/:id/proposals', async (request) => {
+            const id = positiveId(request.params.id, 'id');
+            return request.env(async (raw) => {
+                const env = raw;
+                reconciler(env);
+                return { proposals: await proposalsFor(env, id) };
+            });
+        });
+        context.app.post('/api/v1/accounting/statement-lines/:id/match', async (request) => {
+            const id = positiveId(request.params.id, 'id');
+            const moves = request.body?.moves;
+            if (!Array.isArray(moves) || moves.length === 0)
+                throw new HttpProblem(400, 'invalid-body', 'Invalid request', 'moves is a list of document ids.');
+            const ids = moves.map((m) => positiveId(m, 'moves'));
+            return request.env((raw) => matchLine(raw, id, ids), { write: true });
+        });
+        context.app.post('/api/v1/accounting/statement-lines/:id/write-off', async (request) => {
+            const id = positiveId(request.params.id, 'id');
+            const body = (request.body ?? {});
+            const account = positiveId(body.account, 'account');
+            return request.env((raw) => writeOffLine(raw, id, {
+                account,
+                ...(typeof body.label === 'string' && body.label !== '' ? { label: body.label } : {}),
+            }), { write: true });
+        });
+        context.app.post('/api/v1/accounting/statement-lines/:id/undo', async (request) => {
+            const id = positiveId(request.params.id, 'id');
+            return request.env((raw) => undoLine(raw, id), { write: true });
+        });
+        // Reconciliation rules (RFC 0029 §3.2): run on the open lines now, or a rule's dry run over the last days.
+        context.app.post('/api/v1/accounting/reconcile-rules/run', async (request) => request.env(async (raw) => {
+            const env = raw;
+            reconciler(env);
+            const open = await env
+                .model('account.bank.statement.line')
+                .search({ where: { state: 'open' }, limit: 2000 });
+            return { results: await applyRules(env, open.ids) };
+        }, { write: true }));
+        context.app.get('/api/v1/accounting/reconcile-rules/:id/dry-run', async (request) => {
+            const id = positiveId(request.params.id, 'id');
+            const raw = Number(request.query.days ?? 90);
+            const days = Number.isInteger(raw) && raw > 0 && raw <= 366 ? raw : 90;
+            return request.env((env) => dryRunRule(env, id, days));
+        });
+        context.app.post('/api/v1/accounting/journals/:id/pull', async (request) => {
+            const id = positiveId(request.params.id, 'id');
+            return request.env(async (raw) => {
+                const env = raw;
+                reconciler(env);
+                return pullFeed(env, id);
+            }, { write: true });
+        });
         context.app.post('/api/v1/accounting/reconcile', async (request) => {
             const ids = lineIds(request.body);
             const writeOff = request.body