shutro-erp 0.2.1 → 0.3.1

package/dist/l10n_in/gstr.js

@@ -0,0 +1,430 @@
+/**
+ * The GST returns of a month (RFC 0016 step 5, part 3), from the posted documents: GSTR-1 (outward supplies by the
+ * portal's sections — B2B by recipient GSTIN, B2C large and small, exports, credit and debit notes, nil-rated /
+ * exempt / non-GST, the HSN summary) and GSTR-3B (3.1 outward and reverse-charge inward supplies, 4 input tax credit,
+ * 5 exempt inward supplies, 6.1 the tax payable by head). Filing stays on the GST portal: GSTR-1 also comes as the
+ * portal's offline JSON. Amounts are in rupees: a foreign-currency line converts through its posted balance, as its
+ * taxes do. A line's band is the GST treatment of its GST tax; a line without one is listed as unclassified.
+ */
+import { supplyScope } from '../accounting/index.js';
+import { orm } from '../server/orm.js';
+import { GST_STATE_CODES } from './module.js';
+const ZERO = orm.toDecimal(0);
+const round = (d) => d.toDecimalPlaces(2, orm.Decimal.ROUND_HALF_UP);
+/** B2C invoices between states above this total are reported one by one (B2CL), in rupees. */
+export const B2CL_THRESHOLD = orm.toDecimal(100000);
+export class MonthError extends Error {
+}
+/** The first and last day of `month` (`2026-10`). */
+export function monthRange(month) {
+    const match = /^(\d{4})-(0[1-9]|1[0-2])$/.exec(month);
+    if (match === null)
+        throw new MonthError('A month is written 2026-10.');
+    const last = new Date(Date.UTC(Number(match[1]), Number(match[2]), 0)).getUTCDate();
+    return { from: `${month}-01`, to: `${month}-${String(last).padStart(2, '0')}` };
+}
+const NONE = { txval: ZERO, iamt: ZERO, camt: ZERO, samt: ZERO, csamt: ZERO };
+const add = (a, b) => ({
+    txval: a.txval.plus(b.txval),
+    iamt: a.iamt.plus(b.iamt),
+    camt: a.camt.plus(b.camt),
+    samt: a.samt.plus(b.samt),
+    csamt: a.csamt.plus(b.csamt),
+});
+const neg = (h) => ({
+    txval: h.txval.neg(),
+    iamt: h.iamt.neg(),
+    camt: h.camt.neg(),
+    samt: h.samt.neg(),
+    csamt: h.csamt.neg(),
+});
+/** The company of `env`: its GSTIN, country and state. */
+async function companyOf(env) {
+    const [c] = await env.model('res.company').search({ where: { id: env.companyRef }, limit: 1 });
+    return {
+        gstin: c?.gstin ?? null,
+        country: c?.country ?? null,
+        state: c?.state ?? null,
+    };
+}
+async function documents(env, kinds, month) {
+    const { from, to } = monthRange(month);
+    const company = await companyOf(env);
+    const moves = await env.model('account.move').search({
+        where: {
+            kind: { in: kinds },
+            state: 'posted',
+            date: { gte: from, lte: to },
+        },
+        order: ['date asc', 'name asc'],
+    });
+    const loaded = await moves.load({
+        partner: ['name', 'gstin', 'country', 'state'],
+        reversalOf: ['name', 'date'],
+        debitOf: ['name', 'date'],
+        invoiceLines: { taxes: ['gstTreatment', 'reverseCharge'], product: ['hsnCode'] },
+    });
+    const out = [];
+    for (const m of loaded) {
+        const partnerCountry = m.partner?.country ?? null;
+        const pos = m.placeOfSupply ?? m.partner?.state ?? null;
+        const exported = partnerCountry !== null && company.country !== null && partnerCountry !== company.country;
+        const lines = [];
+        for (const l of m.invoiceLines) {
+            if (l.lineKind !== 'product')
+                continue;
+            const subtotal = l.subtotal?.amount ?? ZERO;
+            // Rupees: the posted balance, and the taxes at its rate.
+            const txval = (l.balance?.amount ?? ZERO).abs();
+            const rate = subtotal.isZero() ? orm.toDecimal(1) : txval.div(subtotal.abs());
+            const head = (d) => round((d ?? ZERO).times(rate));
+            const treatments = [...l.taxes]
+                .map((t) => t.gstTreatment)
+                .filter((t) => t !== null && t !== 'cess');
+            lines.push({
+                txval,
+                iamt: head(l.igstAmount?.amount),
+                camt: head(l.cgstAmount?.amount),
+                samt: head(l.sgstAmount?.amount),
+                csamt: head(l.cessAmount?.amount),
+                treatment: treatments[0] ?? 'unclassified',
+                rate: l.gstRate ?? ZERO,
+                reverseCharge: [...l.taxes].some((t) => t.reverseCharge),
+                hsn: l.product?.hsnCode ?? null,
+                description: l.name ?? '',
+                quantity: l.quantity ?? ZERO,
+            });
+        }
+        const original = m.reversalOf ?? m.debitOf;
+        out.push({
+            kind: m.kind,
+            number: m.name ?? '',
+            date: String(m.date),
+            partner: m.partner?.name ?? '',
+            gstin: m.partner?.gstin ?? null,
+            export: exported,
+            inter: supplyScope(company, partnerCountry, pos) === 'inter',
+            pos,
+            posCode: exported ? '96' : ((pos === null ? undefined : GST_STATE_CODES[pos]) ?? ''),
+            original: original === null ? null : { number: original.name ?? '', date: String(original.date) },
+            lines,
+            value: lines.reduce((s, l) => s.plus(l.txval).plus(l.iamt).plus(l.camt).plus(l.samt).plus(l.csamt), ZERO),
+        });
+    }
+    return out;
+}
+function itemsByRate(lines) {
+    const byRate = new Map();
+    for (const l of lines) {
+        const key = l.rate.toString();
+        const prev = byRate.get(key) ?? { ...NONE, rate: l.rate };
+        byRate.set(key, { ...add(prev, l), rate: l.rate });
+    }
+    return [...byRate.values()];
+}
+/** GSTR-1 of `month`. */
+export async function gstr1(env, month) {
+    const company = await companyOf(env);
+    const docs = await documents(env, ['out_invoice', 'out_debit', 'out_refund'], month);
+    const b2b = [];
+    const b2cl = [];
+    const exp = [];
+    const cdnr = [];
+    const cdnur = [];
+    const b2cs = new Map();
+    const nil = new Map();
+    const hsn = new Map();
+    let unclassified = 0;
+    for (const d of docs) {
+        const note = d.kind === 'out_refund' ? 'C' : d.kind === 'out_debit' ? 'D' : undefined;
+        const sign = note === 'C' ? -1 : 1;
+        const taxable = d.lines.filter((l) => l.treatment === 'taxable' || l.treatment === 'zero_rated');
+        unclassified += d.lines.filter((l) => l.treatment === 'unclassified').length;
+        // Nil-rated, exempt and non-GST supplies: summed by inter / intra and registered / not.
+        for (const l of d.lines) {
+            if (l.treatment !== 'nil' && l.treatment !== 'exempt' && l.treatment !== 'non_gst')
+                continue;
+            const supply = `${d.inter ? 'INTR' : 'INTRA'}${d.gstin === null ? 'B2C' : 'B2B'}`;
+            const row = nil.get(supply) ?? { supply, nil: ZERO, exempt: ZERO, nonGst: ZERO };
+            const v = l.txval.times(sign);
+            if (l.treatment === 'nil')
+                row.nil = row.nil.plus(v);
+            else if (l.treatment === 'exempt')
+                row.exempt = row.exempt.plus(v);
+            else
+                row.nonGst = row.nonGst.plus(v);
+            nil.set(supply, row);
+        }
+        // The HSN summary: every taxable line, notes against it.
+        for (const l of taxable) {
+            const code = l.hsn ?? '';
+            const key = `${code}|${l.rate.toString()}`;
+            const prev = hsn.get(key) ?? {
+                ...NONE,
+                hsn: code,
+                description: l.description,
+                quantity: ZERO,
+                rate: l.rate,
+            };
+            const signed = sign === 1 ? l : neg(l);
+            hsn.set(key, {
+                ...add(prev, signed),
+                hsn: code,
+                description: prev.description,
+                quantity: prev.quantity.plus(l.quantity.times(sign)),
+                rate: l.rate,
+            });
+        }
+        if (taxable.length === 0)
+            continue;
+        const doc = {
+            number: d.number,
+            date: d.date,
+            partner: d.partner,
+            gstin: d.gstin,
+            pos: d.posCode,
+            value: d.value,
+            reverseCharge: taxable.some((l) => l.reverseCharge),
+            items: itemsByRate(taxable),
+            ...(note === undefined ? {} : { noteType: note, original: d.original }),
+            ...(d.export
+                ? {
+                    exportType: taxable.some((l) => l.treatment === 'taxable' && !l.iamt.isZero())
+                        ? 'WPAY'
+                        : 'WOPAY',
+                }
+                : {}),
+        };
+        if (note !== undefined) {
+            if (d.gstin !== null)
+                cdnr.push(doc);
+            else if (d.export || (d.inter && d.value.gt(B2CL_THRESHOLD)))
+                cdnur.push(doc);
+            else
+                for (const item of doc.items)
+                    addB2cs(b2cs, d, sign, item);
+        }
+        else if (d.gstin !== null)
+            b2b.push(doc);
+        else if (d.export)
+            exp.push(doc);
+        else if (d.inter && d.value.gt(B2CL_THRESHOLD))
+            b2cl.push(doc);
+        else
+            for (const item of doc.items)
+                addB2cs(b2cs, d, sign, item);
+    }
+    return {
+        month,
+        gstin: company.gstin,
+        b2b,
+        b2cl,
+        b2cs: [...b2cs.values()],
+        exp,
+        cdnr,
+        cdnur,
+        nil: [...nil.values()],
+        hsn: [...hsn.values()],
+        unclassified,
+    };
+}
+function addB2cs(into, d, sign, item) {
+    const supply = d.inter ? 'INTER' : 'INTRA';
+    const key = `${supply}|${d.posCode}|${item.rate.toString()}`;
+    const prev = into.get(key) ?? { ...NONE, supply, pos: d.posCode, rate: item.rate };
+    into.set(key, {
+        ...add(prev, sign === 1 ? item : neg(item)),
+        supply,
+        pos: d.posCode,
+        rate: item.rate,
+    });
+}
+/** GSTR-3B of `month`. */
+export async function gstr3b(env, month) {
+    const company = await companyOf(env);
+    let outwardTaxable = NONE;
+    let outwardZeroRated = NONE;
+    let outwardNilExempt = NONE;
+    let outwardNonGst = NONE;
+    let inwardReverseCharge = NONE;
+    let itcOther = NONE;
+    let inwardInter = ZERO;
+    let inwardIntra = ZERO;
+    for (const d of await documents(env, ['out_invoice', 'out_debit', 'out_refund'], month)) {
+        const sign = d.kind === 'out_refund' ? -1 : 1;
+        for (const l of d.lines) {
+            const signed = sign === 1 ? l : neg(l);
+            if (l.treatment === 'zero_rated' || (l.treatment === 'taxable' && d.export))
+                outwardZeroRated = add(outwardZeroRated, signed);
+            else if (l.treatment === 'taxable' && !l.reverseCharge)
+                outwardTaxable = add(outwardTaxable, signed);
+            else if (l.treatment === 'nil' || l.treatment === 'exempt')
+                outwardNilExempt = add(outwardNilExempt, { ...NONE, txval: signed.txval });
+            else if (l.treatment === 'non_gst')
+                outwardNonGst = add(outwardNonGst, { ...NONE, txval: signed.txval });
+        }
+    }
+    for (const d of await documents(env, ['in_invoice', 'in_debit', 'in_refund'], month)) {
+        const sign = d.kind === 'in_refund' ? -1 : 1;
+        for (const l of d.lines) {
+            const signed = sign === 1 ? l : neg(l);
+            if (l.treatment === 'taxable' && l.reverseCharge)
+                inwardReverseCharge = add(inwardReverseCharge, signed);
+            else if (l.treatment === 'taxable')
+                itcOther = add(itcOther, signed);
+            else if (l.treatment === 'nil' || l.treatment === 'exempt' || l.treatment === 'non_gst') {
+                if (d.inter)
+                    inwardInter = inwardInter.plus(signed.txval);
+                else
+                    inwardIntra = inwardIntra.plus(signed.txval);
+            }
+        }
+    }
+    const itcReverseCharge = { ...inwardReverseCharge, txval: ZERO };
+    const head = (key) => {
+        const tax = outwardTaxable[key].plus(outwardZeroRated[key]).plus(inwardReverseCharge[key]);
+        const credit = itcReverseCharge[key].plus(itcOther[key]);
+        return { tax, credit, net: tax.minus(credit) };
+    };
+    return {
+        month,
+        gstin: company.gstin,
+        outwardTaxable,
+        outwardZeroRated,
+        outwardNilExempt,
+        inwardReverseCharge,
+        outwardNonGst,
+        itcReverseCharge,
+        itcOther: { ...itcOther, txval: ZERO },
+        inwardExempt: { inter: inwardInter, intra: inwardIntra },
+        payable: { igst: head('iamt'), cgst: head('camt'), sgst: head('samt'), cess: head('csamt') },
+    };
+}
+const money = (d) => Number(d.toFixed(2));
+const portalDate = (iso) => `${iso.slice(8, 10)}-${iso.slice(5, 7)}-${iso.slice(0, 4)}`;
+const portalItems = (items, exportOnly = false) => items.map((it, i) => ({
+    num: i + 1,
+    itm_det: exportOnly
+        ? {
+            txval: money(it.txval),
+            rt: Number(it.rate.toString()),
+            iamt: money(it.iamt),
+            csamt: money(it.csamt),
+        }
+        : {
+            txval: money(it.txval),
+            rt: Number(it.rate.toString()),
+            iamt: money(it.iamt),
+            camt: money(it.camt),
+            samt: money(it.samt),
+            csamt: money(it.csamt),
+        },
+}));
+/**
+ * GSTR-1 as the GST portal's offline JSON (the sections b2b, b2cl, b2cs, exp, cdnr, cdnur, nil, hsn). Check it against
+ * the current offline tool's schema before uploading: the portal changes it from time to time.
+ */
+export function gstr1PortalJson(r) {
+    const [y, m] = r.month.split('-');
+    const byGstin = (docs, key, note) => {
+        const out = new Map();
+        for (const d of docs) {
+            const list = out.get(d.gstin ?? '') ?? [];
+            list.push(note
+                ? {
+                    ntty: d.noteType,
+                    nt_num: d.number,
+                    nt_dt: portalDate(d.date),
+                    val: money(d.value),
+                    pos: d.pos,
+                    rchrg: d.reverseCharge ? 'Y' : 'N',
+                    inv_typ: 'R',
+                    itms: portalItems(d.items),
+                }
+                : {
+                    inum: d.number,
+                    idt: portalDate(d.date),
+                    val: money(d.value),
+                    pos: d.pos,
+                    rchrg: d.reverseCharge ? 'Y' : 'N',
+                    inv_typ: 'R',
+                    itms: portalItems(d.items),
+                });
+            out.set(d.gstin ?? '', list);
+        }
+        return [...out.entries()].map(([ctin, list]) => ({ ctin, [key]: list }));
+    };
+    const b2clByPos = new Map();
+    for (const d of r.b2cl) {
+        const list = b2clByPos.get(d.pos) ?? [];
+        list.push({
+            inum: d.number,
+            idt: portalDate(d.date),
+            val: money(d.value),
+            itms: portalItems(d.items),
+        });
+        b2clByPos.set(d.pos, list);
+    }
+    const expByType = new Map();
+    for (const d of r.exp) {
+        const list = expByType.get(d.exportType ?? 'WOPAY') ?? [];
+        list.push({
+            inum: d.number,
+            idt: portalDate(d.date),
+            val: money(d.value),
+            itms: portalItems(d.items, true),
+        });
+        expByType.set(d.exportType ?? 'WOPAY', list);
+    }
+    return {
+        gstin: r.gstin ?? '',
+        fp: `${m}${y}`,
+        b2b: byGstin(r.b2b, 'inv', false),
+        b2cl: [...b2clByPos.entries()].map(([pos, inv]) => ({ pos, inv })),
+        b2cs: r.b2cs.map((s) => ({
+            sply_ty: s.supply,
+            pos: s.pos,
+            typ: 'OE',
+            rt: Number(s.rate.toString()),
+            txval: money(s.txval),
+            iamt: money(s.iamt),
+            camt: money(s.camt),
+            samt: money(s.samt),
+            csamt: money(s.csamt),
+        })),
+        exp: [...expByType.entries()].map(([exp_typ, inv]) => ({ exp_typ, inv })),
+        cdnr: byGstin(r.cdnr, 'nt', true),
+        cdnur: r.cdnur.map((d) => ({
+            typ: d.exportType === undefined ? 'B2CL' : d.exportType === 'WPAY' ? 'EXPWP' : 'EXPWOP',
+            ntty: d.noteType,
+            nt_num: d.number,
+            nt_dt: portalDate(d.date),
+            val: money(d.value),
+            pos: d.pos,
+            itms: portalItems(d.items),
+        })),
+        nil: {
+            inv: r.nil.map((n) => ({
+                sply_ty: n.supply,
+                nil_amt: money(n.nil),
+                expt_amt: money(n.exempt),
+                ngsup_amt: money(n.nonGst),
+            })),
+        },
+        hsn: {
+            data: r.hsn.map((h, i) => ({
+                num: i + 1,
+                hsn_sc: h.hsn,
+                desc: h.description,
+                uqc: 'NOS',
+                qty: Number(h.quantity.toString()),
+                rt: Number(h.rate.toString()),
+                txval: money(h.txval),
+                iamt: money(h.iamt),
+                camt: money(h.camt),
+                samt: money(h.samt),
+                csamt: money(h.csamt),
+            })),
+        },
+    };
+}

package/dist/l10n_in/index.d.ts

@@ -0,0 +1,20 @@
+import { type KoshModule, type LocalizationSpec } from '../modules-sdk/index.js';
+import { type GstProvider } from './einvoice.js';
+export { GST_DOCUMENTS } from './documents.js';
+export { CANCEL_REASONS, cancelEInvoice, cancelEwayBill, createFakeGstProvider, type EInvoicePayload, type EwayBillPayload, einvoicePayload, einvoiceState, financialYear, type GstProvider, GstProviderError, generateEwayBill, gstProviderFromEnv, irnOf, registerEInvoice, } from './einvoice.js';
+export { B2CL_THRESHOLD, type Gstr1, type Gstr1Document, type Gstr3b, gstr1, gstr1PortalJson, gstr3b, type Heads, MonthError, monthRange, } from './gstr.js';
+export { CESS_RATES, CompanyGst, GST_RATES, GST_STATE_CODES, GST_TREATMENTS, type GstAmounts, gstAmounts, gstinCheckDigit, gstinProblem, LineGst, l10nInShutro, MoveGst, PartnerGst, ProductHsn, TAXES, TaxGst, } from './module.js';
+export { registerGstRoutes } from './routes.js';
+export { einvoiceWorker, registerEInvoiceRoutes } from './routes-einvoice.js';
+/** India, as Accounting installs it for a company. */
+export declare const INDIA: LocalizationSpec;
+/** What an installation may set instead of the environment (`KOSH_GST_PROVIDER`). */
+export interface L10nInOptions {
+    /** The IRP / e-way bill provider; default: the environment's, or none (e-invoicing unavailable). */
+    readonly provider?: GstProvider | undefined;
+    /** Start the subscriber registering posted documents (default: unless `KOSH_SCHEDULES=off`). */
+    readonly workers?: boolean | undefined;
+}
+/** The India localization with an explicit provider (tests, installations wiring their own). */
+export declare function l10nInModule(options?: L10nInOptions): KoshModule;
+export declare const l10nIn: KoshModule;

package/dist/l10n_in/index.js

@@ -0,0 +1,232 @@
+/**
+ * @packageDocumentation
+ * `shutro-erp/l10n_in` (RFC 0016 step 5): Kosh for a company in India. Installing it sets each company without a chart up
+ * for the country: the chart of accounts (CGST, SGST, IGST and cess payable and input credit, GST under reverse
+ * charge, TDS), the accounts of the GST taxes and their components, the TDS withholdings, an April–March fiscal
+ * year and lakh / crore grouping. Contacts and companies get their GSTIN and PAN, products their HSN / SAC code.
+ * The company's state (Accounting › Settings) decides which invoices are within the state.
+ *
+ * Rates are those of the GST slabs and the income tax TDS sections as commonly applied; rates and thresholds change
+ * with GST Council decisions and each Finance Act: check them in Accounting › Configuration.
+ */
+import { accounting, COMMON_ACCOUNTS, DEFAULT_ACCOUNTS, installedChart, installLocalization, } from '../accounting/index.js';
+import { contacts } from '../contacts/index.js';
+import { defineModule } from '../modules-sdk/index.js';
+import { field } from '../views/index.js';
+import { GST_DOCUMENTS } from './documents.js';
+import { gstProviderFromEnv } from './einvoice.js';
+import { CESS_RATES, GST_RATES, l10nInShutro } from './module.js';
+import { registerGstRoutes } from './routes.js';
+import { einvoiceWorker, registerEInvoiceRoutes } from './routes-einvoice.js';
+export { GST_DOCUMENTS } from './documents.js';
+export { CANCEL_REASONS, cancelEInvoice, cancelEwayBill, createFakeGstProvider, einvoicePayload, einvoiceState, financialYear, GstProviderError, generateEwayBill, gstProviderFromEnv, irnOf, registerEInvoice, } from './einvoice.js';
+export { B2CL_THRESHOLD, gstr1, gstr1PortalJson, gstr3b, MonthError, monthRange, } from './gstr.js';
+export { CESS_RATES, CompanyGst, GST_RATES, GST_STATE_CODES, GST_TREATMENTS, gstAmounts, gstinCheckDigit, gstinProblem, LineGst, l10nInShutro, MoveGst, PartnerGst, ProductHsn, TAXES, TaxGst, } from './module.js';
+export { registerGstRoutes } from './routes.js';
+export { einvoiceWorker, registerEInvoiceRoutes } from './routes-einvoice.js';
+const id = (rate) => rate.replace('.', '_');
+/** The accounts of every GST component: output tax on sales, input credit on purchases, both under reverse charge. */
+function componentAccounts() {
+    const out = {};
+    const heads = [
+        ['cgst', '2310', '1310', '2320'],
+        ['sgst', '2311', '1311', '2321'],
+        ['igst', '2312', '1312', '2322'],
+    ];
+    for (const rate of GST_RATES)
+        for (const [head, output, input] of heads) {
+            out[`l10n_in.gst_sale_${id(rate)}_${head}`] = output;
+            out[`l10n_in.gst_purchase_${id(rate)}_${head}`] = input;
+        }
+    for (const rate of ['5', '12', '18', '28'])
+        for (const [head, , input, payable] of heads)
+            out[`l10n_in.gst_rc_${id(rate)}_${head}`] = { account: input, reverseCharge: payable };
+    return out;
+}
+/** India, as Accounting installs it for a company. */
+export const INDIA = {
+    key: 'in',
+    country: 'IN',
+    label: 'India',
+    chart: {
+        accounts: [
+            ...COMMON_ACCOUNTS,
+            { code: '2310', name: 'CGST payable', type: 'liability_current' },
+            { code: '2311', name: 'SGST / UTGST payable', type: 'liability_current' },
+            { code: '2312', name: 'IGST payable', type: 'liability_current' },
+            { code: '2313', name: 'Compensation cess payable', type: 'liability_current' },
+            { code: '1310', name: 'CGST input credit', type: 'asset_current' },
+            { code: '1311', name: 'SGST / UTGST input credit', type: 'asset_current' },
+            { code: '1312', name: 'IGST input credit', type: 'asset_current' },
+            { code: '1313', name: 'Compensation cess input credit', type: 'asset_current' },
+            { code: '2320', name: 'CGST payable under reverse charge', type: 'liability_current' },
+            { code: '2321', name: 'SGST payable under reverse charge', type: 'liability_current' },
+            { code: '2322', name: 'IGST payable under reverse charge', type: 'liability_current' },
+            { code: '2330', name: 'TDS payable', type: 'liability_current' },
+            { code: '1330', name: 'TDS receivable', type: 'asset_current' },
+        ],
+        defaults: DEFAULT_ACCOUNTS,
+        taxAccounts: { sale: '2312', purchase: '1312' },
+    },
+    taxes: Object.fromEntries(CESS_RATES.flatMap((r) => [
+        [`l10n_in.cess_sale_${id(r)}`, '2313'],
+        [`l10n_in.cess_purchase_${id(r)}`, '1313'],
+    ])),
+    components: componentAccounts(),
+    withholdings: [
+        // Income tax deducted at source when paying vendors (sections of the Income-tax Act; thresholds are annual or
+        // per payment by section: check them, they are not applied per document here).
+        {
+            name: 'TDS 194C 1% (contractors, individuals)',
+            direction: 'vendor',
+            base: 'untaxed',
+            rate: '0.01',
+            account: '2330',
+        },
+        {
+            name: 'TDS 194C 2% (contractors, others)',
+            direction: 'vendor',
+            base: 'untaxed',
+            rate: '0.02',
+            account: '2330',
+        },
+        {
+            name: 'TDS 194J 10% (professional fees)',
+            direction: 'vendor',
+            base: 'untaxed',
+            rate: '0.10',
+            account: '2330',
+        },
+        {
+            name: 'TDS 194J 2% (technical services)',
+            direction: 'vendor',
+            base: 'untaxed',
+            rate: '0.02',
+            account: '2330',
+        },
+        {
+            name: 'TDS 194H 2% (commission)',
+            direction: 'vendor',
+            base: 'untaxed',
+            rate: '0.02',
+            account: '2330',
+        },
+        {
+            name: 'TDS 194-I 10% (rent of buildings)',
+            direction: 'vendor',
+            base: 'untaxed',
+            rate: '0.10',
+            account: '2330',
+        },
+        // What customers deduct from our invoices (claimed against our income tax).
+        {
+            name: 'TDS deducted by customers 2%',
+            direction: 'customer',
+            base: 'untaxed',
+            rate: '0.02',
+            account: '1330',
+        },
+    ],
+    fiscalYearStart: 4,
+    grouping: 'lakh',
+};
+/** Sets up the company of `env` for India when it has no chart yet, or completes an India setup. */
+async function localize(raw) {
+    // Accounting's environment: the installer reads Accounting's models.
+    const env = raw;
+    const companies = await env
+        .model('res.company')
+        .search({ where: { id: env.companyRef }, limit: 1 });
+    if (companies.length === 0)
+        return undefined; // no company yet (before installBase)
+    const chart = await installedChart(env);
+    if (chart !== null && chart !== INDIA.key)
+        return undefined; // another chart: the company's choice
+    const done = await installLocalization(env, INDIA);
+    return done.chart === null
+        ? undefined
+        : `the India chart (${done.chart.accounts} accounts), ${done.taxes} taxes, ${done.withholdings} withholdings`;
+}
+/** The India localization with an explicit provider (tests, installations wiring their own). */
+export function l10nInModule(options = {}) {
+    return defineModule({
+        shutro: l10nInShutro,
+        kosh: '^0.1.0',
+        depends: [accounting, contacts],
+        accessLevels: {
+            manager: { label: 'India localization', groups: ['account.manager'] },
+        },
+        localization: INDIA,
+        hooks: { defaults: (env) => localize(env) },
+        routes: (context) => {
+            registerGstRoutes(context);
+            const provider = options.provider ?? gstProviderFromEnv();
+            registerEInvoiceRoutes(context, provider);
+            if (provider === undefined || !(options.workers ?? process.env['KOSH_SCHEDULES'] !== 'off'))
+                return;
+            const worker = einvoiceWorker(context, provider);
+            worker.start();
+            context.app.addHook('onClose', async () => {
+                await worker.stop();
+            });
+        },
+        // Accounting › Reporting › GST returns: GSTR-1 and GSTR-3B.
+        actions: {
+            'l10n_in.action_gst': {
+                type: 'client',
+                page: 'l10n_in.Gst',
+                label: 'GST returns',
+                visibleTo: ['account.user'],
+            },
+        },
+        menus: [
+            {
+                id: 'l10n_in.gst',
+                parent: 'accounting.reporting',
+                label: 'GST returns',
+                action: 'l10n_in.action_gst',
+                sequence: 8,
+            },
+        ],
+        // The tax invoice, the credit and debit notes (printed when Reporting is installed).
+        documents: GST_DOCUMENTS,
+        viewExtensions: [
+            // The GSTIN and PAN with a contact's identity, for contacts in India.
+            {
+                view: 'res.partner.form',
+                operations: [
+                    {
+                        append: 'identity',
+                        nodes: [
+                            field({ field: 'gstin', id: 'gstin', visibleWhen: { country: 'IN' } }),
+                            field({ field: 'pan', id: 'pan', visibleWhen: { country: 'IN' } }),
+                        ],
+                    },
+                ],
+            },
+            // On posted customer invoices and notes: the e-invoice and the e-way bill.
+            {
+                view: 'account.move.invoice.form',
+                operations: [
+                    {
+                        insertAfter: 'register_payment',
+                        nodes: [{ kind: 'component', id: 'einvoice', component: 'l10n_in.EInvoice' }],
+                    },
+                ],
+            },
+            // A product's HSN / SAC code.
+            {
+                view: 'product.product.form',
+                operations: [{ append: 'identity', nodes: [field({ field: 'hsnCode', id: 'hsn_code' })] }],
+            },
+            // Where a tax goes in the GST returns.
+            {
+                view: 'account.tax.form',
+                operations: [
+                    { append: 'main', nodes: [field({ field: 'gstTreatment', id: 'gst_treatment' })] },
+                ],
+            },
+        ],
+    });
+}
+export const l10nIn = l10nInModule();