shutro-erp 0.3.1 → 0.3.3

package/dist/integrations/web/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/integrations`: the tools on a webhook's form (test event, new secret, the events
+ * offered), on a delivery's (send again), on an inbound webhook's (its URL, a new secret) and on an inbound call's
+ * (handle again).
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { DeliveryTools } from './DeliveryTools.js';
+export { EndpointTools } from './EndpointTools.js';
+export { InboundTools } from './InboundTools.js';
+export { WebhookTools } from './WebhookTools.js';
+/** Registers the components (and the messages in `i18n`, when given). */
+export declare function registerIntegrationsWeb(registry: Registry, i18n?: i18n): Registry;
+export { messages as integrationsMessages };

package/dist/integrations/web/index.js

@@ -0,0 +1,27 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/integrations`: the tools on a webhook's form (test event, new secret, the events
+ * offered), on a delivery's (send again), on an inbound webhook's (its URL, a new secret) and on an inbound call's
+ * (handle again).
+ */
+import { addMessages } from '../../ui/index.js';
+import { DeliveryTools } from './DeliveryTools.js';
+import { EndpointTools } from './EndpointTools.js';
+import { InboundTools } from './InboundTools.js';
+import { messages } from './messages.js';
+import { WebhookTools } from './WebhookTools.js';
+export { DeliveryTools } from './DeliveryTools.js';
+export { EndpointTools } from './EndpointTools.js';
+export { InboundTools } from './InboundTools.js';
+export { WebhookTools } from './WebhookTools.js';
+/** Registers the components (and the messages in `i18n`, when given). */
+export function registerIntegrationsWeb(registry, i18n) {
+    registry.registerComponent('integrations.WebhookTools', WebhookTools);
+    registry.registerComponent('integrations.DeliveryTools', DeliveryTools);
+    registry.registerComponent('integrations.EndpointTools', EndpointTools);
+    registry.registerComponent('integrations.InboundTools', InboundTools);
+    if (i18n !== undefined)
+        addMessages(i18n, 'integrations', messages);
+    return registry;
+}
+export { messages as integrationsMessages };

package/dist/integrations/web/messages.d.ts

@@ -0,0 +1,2 @@
+/** Messages of the Integrations app (namespace `integrations`), in English and Bangla. */
+export declare const messages: Readonly<Record<string, object>>;

package/dist/integrations/web/messages.js

@@ -0,0 +1,53 @@
+/** Messages of the Integrations app (namespace `integrations`), in English and Bangla. */
+export const messages = {
+    en: {
+        tools: {
+            title: 'Webhook tools',
+            ping: 'Send a test event',
+            pinged: 'A test event is on its way: see Deliveries.',
+            rotate: 'New signing secret',
+            events: 'Events you can subscribe to',
+            eventsHint: 'Put the events in the Events field, separated by spaces. A record’s payload is what the webhook’s user may read.',
+            replay: 'Send again',
+            replayed: 'Sent again: a new delivery is in Deliveries.',
+        },
+        endpoint: {
+            title: 'Inbound webhook',
+            url: 'URL to give the provider',
+            urlHint: 'Calls are checked with the secret; refused ones stay in Inbound calls.',
+            rotate: 'New secret',
+            hooks: 'Endpoints the installed apps offer',
+            hooksHint: 'Put one of them in the Endpoint field.',
+            none: 'No installed app offers an inbound webhook.',
+        },
+        inbound: {
+            replay: 'Handle again',
+            replayed: 'Queued: the outcome appears here shortly.',
+        },
+    },
+    bn: {
+        tools: {
+            title: 'ওয়েবহুক সরঞ্জাম',
+            ping: 'পরীক্ষামূলক ইভেন্ট পাঠান',
+            pinged: 'পরীক্ষামূলক ইভেন্ট পাঠানো হচ্ছে: ডেলিভারি দেখুন।',
+            rotate: 'নতুন স্বাক্ষর গোপন কী',
+            events: 'যেসব ইভেন্টে সাবস্ক্রাইব করা যায়',
+            eventsHint: 'ইভেন্টগুলো ইভেন্ট ঘরে ফাঁকা জায়গা দিয়ে আলাদা করে লিখুন। রেকর্ডের তথ্য ওয়েবহুকের ব্যবহারকারী যা পড়তে পারেন ততটুকুই।',
+            replay: 'আবার পাঠান',
+            replayed: 'আবার পাঠানো হয়েছে: ডেলিভারিতে নতুন একটি আছে।',
+        },
+        endpoint: {
+            title: 'ইনবাউন্ড ওয়েবহুক',
+            url: 'প্রোভাইডারকে দেওয়ার URL',
+            urlHint: 'প্রতিটি কল গোপন কী দিয়ে যাচাই হয়; প্রত্যাখ্যাত কল ইনবাউন্ড কলে থাকে।',
+            rotate: 'নতুন গোপন কী',
+            hooks: 'ইনস্টল করা অ্যাপগুলোর এন্ডপয়েন্ট',
+            hooksHint: 'এর একটি এন্ডপয়েন্ট ঘরে লিখুন।',
+            none: 'কোনো ইনস্টল করা অ্যাপ ইনবাউন্ড ওয়েবহুক দেয় না।',
+        },
+        inbound: {
+            replay: 'আবার প্রক্রিয়া করুন',
+            replayed: 'সারিতে আছে: ফলাফল শীঘ্রই এখানে দেখা যাবে।',
+        },
+    },
+};

package/dist/integrations/webhooks.d.ts

@@ -0,0 +1,63 @@
+import { type AuthService, type KoshRegistry } from '../server/index.js';
+import type { Env, Shutro } from '../server/orm.js';
+export declare const DELIVER_JOB = "webhook.deliver";
+export declare const CHANGE_TOPIC = "record.changed";
+/** Shutro's change actions and the events they are. */
+export declare const CHANGE_EVENTS: Readonly<Record<string, string>>;
+/** The test event a "send a test" sends. */
+export declare const PING_EVENT = "webhook.ping";
+export interface IntegrationsContext {
+    readonly shutro: Shutro;
+    readonly registry: KoshRegistry;
+    readonly auth?: AuthService | undefined;
+    /** For tests: the HTTP client deliveries use. */
+    readonly fetch?: typeof fetch;
+}
+/** The hosts webhooks may call (`SHUTRO_ERP_WEBHOOK_HOSTS`, else automation's list; `*.example.com` allowed). */
+export declare function webhookHosts(env?: Readonly<Record<string, string | undefined>>): string[];
+/** Why a URL may not be called, or `null`: https (http for localhost), and a host on the allow-list. */
+export declare function urlProblem(url: string, hosts?: readonly string[]): string | null;
+/** `t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<body>">`: what receivers check (and reject when old). */
+export declare function signature(secret: string, body: string, time: number): string;
+export interface WebhookEvent {
+    readonly event: string;
+    readonly model: string;
+    readonly label: string;
+}
+/** The events subscriptions may want here: each served model's changes, and the modules' declared events. */
+export declare function webhookEvents(registry: KoshRegistry): WebhookEvent[];
+interface Rows {
+    readonly ids: readonly number[];
+    readonly length: number;
+    load(spec: unknown): Promise<Rows>;
+    read(keys: readonly string[]): Record<string, unknown>[];
+    write(values: unknown): Promise<void>;
+}
+interface Ref {
+    search(query: unknown): Promise<Rows>;
+    browse(ids: readonly number[]): Rows;
+    create(rows: readonly unknown[]): Promise<Rows>;
+}
+export declare const ref: (env: Env, model: string) => Ref;
+/**
+ * Turns an event into deliveries for the matching active subscriptions of `company`, one per record, and queues
+ * them. Returns the deliveries made.
+ */
+export declare function fanOut(context: IntegrationsContext, input: {
+    readonly event: string;
+    readonly model: string;
+    readonly ids: readonly number[];
+    readonly company: number;
+    readonly extra?: Readonly<Record<string, unknown>>;
+}): Promise<number[]>;
+/** A new delivery of `payload` to a subscription, queued; returns its id. */
+export declare function queue(context: IntegrationsContext, subscription: number, company: number, event: string, payload: Record<string, unknown>, replayOf?: number): Promise<number>;
+/**
+ * Sends one delivery and records the attempt (in its own transaction, so a retry keeps it). Throws to be retried
+ * while attempts remain; the last failure marks the delivery failed and counts against the subscription.
+ */
+export declare function deliver(context: IntegrationsContext, delivery: number, company: number, attempt: {
+    readonly number: number;
+    readonly last: boolean;
+}): Promise<void>;
+export {};

package/dist/integrations/webhooks.js

@@ -0,0 +1,217 @@
+/**
+ * Outbound webhooks (RFC 0017 §5.3). Events — a record created, updated or deleted (Shutro's change events), or an
+ * event a module declares (`account.move.posted`) — become deliveries for the active subscriptions that want them;
+ * each delivery is a job that POSTs `{ id, event, occurredAt, data }`, signed, and records every attempt. A failure
+ * is retried with Shutro's back-off; the last one marks the delivery failed. The record in a payload is what the
+ * subscription's user would get from `GET /api/v1/models/<model>/<id>`: their rights, their fields.
+ */
+import { createHmac, randomUUID } from 'node:crypto';
+import { publicApiModels, readApiRecord, } from '../server/index.js';
+export const DELIVER_JOB = 'webhook.deliver';
+export const CHANGE_TOPIC = 'record.changed';
+/** Shutro's change actions and the events they are. */
+export const CHANGE_EVENTS = {
+    create: 'created',
+    write: 'updated',
+    unlink: 'deleted',
+};
+/** The test event a "send a test" sends. */
+export const PING_EVENT = 'webhook.ping';
+/** The hosts webhooks may call (`SHUTRO_ERP_WEBHOOK_HOSTS`, else automation's list; `*.example.com` allowed). */
+export function webhookHosts(env = process.env) {
+    return (env['KOSH_WEBHOOK_HOSTS'] ?? env['KOSH_AUTOMATION_WEBHOOK_HOSTS'] ?? '')
+        .split(',')
+        .map((h) => h.trim().toLowerCase())
+        .filter((h) => h !== '');
+}
+/** Why a URL may not be called, or `null`: https (http for localhost), and a host on the allow-list. */
+export function urlProblem(url, hosts = webhookHosts()) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `Not a URL: '${url}'.`;
+    }
+    const host = parsed.hostname.toLowerCase();
+    const local = host === 'localhost' || host === '127.0.0.1';
+    if (parsed.protocol !== 'https:' && !(parsed.protocol === 'http:' && local))
+        return 'Webhooks call https URLs (http only for localhost).';
+    if (!hosts.some((h) => (h.startsWith('*.') ? host.endsWith(h.slice(1)) : host === h)))
+        return `The host ${host} is not on the webhook allow-list (SHUTRO_ERP_WEBHOOK_HOSTS).`;
+    return null;
+}
+/** `t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<body>">`: what receivers check (and reject when old). */
+export function signature(secret, body, time) {
+    return `t=${time},v1=${createHmac('sha256', secret).update(`${time}.${body}`).digest('hex')}`;
+}
+/** The events subscriptions may want here: each served model's changes, and the modules' declared events. */
+export function webhookEvents(registry) {
+    const out = [];
+    for (const model of publicApiModels(registry).values())
+        for (const [, verb] of Object.entries(CHANGE_EVENTS))
+            out.push({
+                event: `${model.name}.${verb}`,
+                model: model.name,
+                label: `${model.label} ${verb}`,
+            });
+    for (const m of registry.loaded.modules)
+        for (const e of m.events ?? [])
+            out.push({ event: e.topic, model: e.model, label: e.label });
+    return out.sort((a, b) => a.event.localeCompare(b.event));
+}
+export const ref = (env, model) => env.model(model);
+async function rowsOf(set, keys) {
+    return set.length === 0 ? [] : (await set.load(keys)).read(['id', ...keys]);
+}
+/** Runs `fn` as `user` in `company` (their groups and grants), for reading what they may see. */
+async function asUser(context, user, company, fn) {
+    const identity = await context.auth?.verify(user);
+    if (identity === null || identity === undefined || !identity.companies.includes(company))
+        return null;
+    try {
+        return await context.shutro.run({
+            user,
+            company,
+            groups: [...identity.groups],
+            grants: [...(identity.grants ?? [])],
+        }, fn);
+    }
+    catch (error) {
+        // Their roles do not let them read it: as good as not visible.
+        if (error instanceof Error && error.name === 'AccessError')
+            return null;
+        throw error;
+    }
+}
+/** Whether record `id` of `model` still exists (whoever may see it). */
+async function exists(context, model, id, company) {
+    return context.shutro.bootstrap({ reason: 'webhooks: still there?', company }, async (env) => env.asSuperuser({ reason: 'webhooks: does the record still exist' }, async (su) => (await ref(su, model).search({ where: { id }, limit: 1 })).length > 0));
+}
+/**
+ * Turns an event into deliveries for the matching active subscriptions of `company`, one per record, and queues
+ * them. Returns the deliveries made.
+ */
+export async function fanOut(context, input) {
+    // System work outside any company (installation) has no company's webhooks to tell.
+    if (!(Number.isSafeInteger(input.company) && input.company > 0))
+        return [];
+    const apiModel = publicApiModels(context.registry).get(input.model);
+    const subscriptions = await context.shutro.bootstrap({ reason: `webhooks: ${input.event}`, company: input.company }, async (env) => (await rowsOf(await ref(env, 'webhook.subscription').search({
+        where: { active: true, company: input.company },
+    }), ['events', 'runAs', 'createdBy'])).filter((s) => String(s['events']).split(/\s+/).includes(input.event)));
+    if (subscriptions.length === 0)
+        return [];
+    const made = [];
+    for (const sub of subscriptions) {
+        const user = (sub['runAs'] ?? sub['createdBy']);
+        for (const id of input.ids) {
+            let record = null;
+            if (!input.event.endsWith('.deleted') && apiModel !== undefined && user !== null) {
+                record = await asUser(context, user, input.company, (env) => readApiRecord(env, apiModel, id));
+                // Not theirs to see: nothing is sent. Gone since (deleted after this change): sent without the record.
+                if (record === null && (await exists(context, input.model, id, input.company)))
+                    continue;
+            }
+            const payload = {
+                id: randomUUID(),
+                event: input.event,
+                occurredAt: new Date().toISOString(),
+                data: { model: input.model, id, record, ...input.extra },
+            };
+            made.push(await queue(context, sub['id'], input.company, input.event, payload));
+        }
+    }
+    return made;
+}
+/** A new delivery of `payload` to a subscription, queued; returns its id. */
+export async function queue(context, subscription, company, event, payload, replayOf) {
+    return context.shutro.bootstrap({ reason: `webhook delivery ${event}`, company }, async (env) => {
+        const created = await ref(env, 'webhook.delivery').create([
+            { subscription, event, payload, company, ...(replayOf === undefined ? {} : { replayOf }) },
+        ]);
+        const id = created.ids[0];
+        await env.enqueue(DELIVER_JOB, { delivery: id, company }, { attempts: 8 });
+        return id;
+    });
+}
+/**
+ * Sends one delivery and records the attempt (in its own transaction, so a retry keeps it). Throws to be retried
+ * while attempts remain; the last failure marks the delivery failed and counts against the subscription.
+ */
+export async function deliver(context, delivery, company, attempt) {
+    const system = (fn) => context.shutro.bootstrap({ reason: `webhook delivery ${delivery}`, company }, fn);
+    const found = await system(async (env) => {
+        const [d] = await rowsOf(ref(env, 'webhook.delivery').browse([delivery]), [
+            'subscription',
+            'event',
+            'payload',
+            'attempts',
+            'state',
+        ]);
+        if (d === undefined)
+            return null;
+        const [s] = await rowsOf(ref(env, 'webhook.subscription').browse([d['subscription']]), ['url', 'secret', 'active', 'failures']);
+        return s === undefined ? null : { d, s };
+    });
+    if (found === null || found.d['state'] === 'done')
+        return;
+    const { d, s } = found;
+    const record = (values, subscription) => system(async (env) => {
+        await ref(env, 'webhook.delivery').browse([delivery]).write(values);
+        if (subscription !== undefined)
+            await ref(env, 'webhook.subscription')
+                .browse([s['id']])
+                .write(subscription);
+    });
+    const attempts = Number(d['attempts'] ?? 0) + 1;
+    const problem = s['active'] !== true ? 'The webhook is switched off.' : urlProblem(String(s['url']));
+    if (problem !== null) {
+        await record({ state: 'failed', attempts, error: problem });
+        return;
+    }
+    const body = JSON.stringify(d['payload']);
+    const payload = d['payload'];
+    const started = Date.now();
+    let status = null;
+    let text = '';
+    let error = null;
+    try {
+        const response = await (context.fetch ?? fetch)(String(s['url']), {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'user-agent': 'Shutro-ERP-Webhooks/1',
+                'x-shutro-event': String(d['event']),
+                'x-shutro-delivery': String(payload.id ?? delivery),
+                'x-shutro-signature': signature(String(s['secret']), body, Math.floor(started / 1000)),
+            },
+            body,
+            signal: AbortSignal.timeout(10_000),
+            redirect: 'manual',
+        });
+        status = response.status;
+        text = (await response.text().catch(() => '')).slice(0, 2048);
+        if (!response.ok)
+            error = `The endpoint answered ${response.status}.`;
+    }
+    catch (e) {
+        error = e instanceof Error ? e.message : String(e);
+    }
+    const outcome = {
+        attempts,
+        responseStatus: status,
+        responseBody: text,
+        durationMs: Date.now() - started,
+        error,
+    };
+    if (error === null) {
+        await record({ ...outcome, state: 'done', deliveredAt: new Date() }, { failures: 0, lastDeliveryAt: new Date() });
+        return;
+    }
+    if (!attempt.last) {
+        await record({ ...outcome, state: 'pending' });
+        throw new Error(error); // retried with back-off
+    }
+    await record({ ...outcome, state: 'failed' }, { failures: Number(s['failures'] ?? 0) + 1 });
+}

package/dist/l10n_bd/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 52fb4c0464f10e60
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 679842f099351542
 // Bindings of module `l10n_bd`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';

package/dist/l10n_bd/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 52fb4c0464f10e60
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 679842f099351542
 // Schema view of module `l10n_bd` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -24,6 +24,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -635,6 +636,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    readonly createdAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly updatedAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly createdBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly updatedBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly displayName: F.Char<{ readonly required: true; readonly readonly: true; readonly compute: true }>;
+    readonly twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -1129,6 +1150,13 @@ export interface ResCompany {
     readonly name: F.Char<{ readonly required: true }>;
     readonly currency: F.Many2one<'res.currency', { readonly required: true }>;
     readonly numberGrouping: F.Selection<'international' | 'lakh', { readonly required: true; readonly default: true }>;
+    readonly accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
     readonly fiscalYearStart: F.Integer<{ readonly required: true; readonly default: true }>; // accounting
     readonly chartTemplate: F.Char; // accounting
     readonly country: F.Char; // accounting

package/dist/l10n_in/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 3a48057268d9c891
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8a0fa1636d2ec016
 // Bindings of module `l10n_in`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';

package/dist/l10n_in/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 3a48057268d9c891
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8a0fa1636d2ec016
 // Schema view of module `l10n_in` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -24,6 +24,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -657,6 +658,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    readonly createdAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly updatedAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly createdBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly updatedBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly displayName: F.Char<{ readonly required: true; readonly readonly: true; readonly compute: true }>;
+    readonly twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -1187,6 +1208,13 @@ export interface ResCompany {
     readonly name: F.Char<{ readonly required: true }>;
     readonly currency: F.Many2one<'res.currency', { readonly required: true }>;
     readonly numberGrouping: F.Selection<'international' | 'lakh', { readonly required: true; readonly default: true }>;
+    readonly accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
     readonly fiscalYearStart: F.Integer<{ readonly required: true; readonly default: true }>; // accounting
     readonly chartTemplate: F.Char; // accounting
     readonly country: F.Char; // accounting
@@ -1200,9 +1228,6 @@ export interface ResCompany {
     readonly accountRetainedEarnings: F.Many2one<'account.account'>; // accounting
     readonly gstin: F.Char; // l10n_in
     readonly pan: F.Char; // l10n_in
-    readonly street: F.Char; // l10n_in
-    readonly city: F.Char; // l10n_in
-    readonly zip: F.Char; // l10n_in
     readonly einvoiceEnabled: F.Bool<{ readonly required: true; readonly default: true }>; // l10n_in
   };
   readonly methods: ResCompanyMethods;

package/dist/l10n_in/module.d.ts

@@ -51,37 +51,6 @@ export declare const CompanyGst: import("../server/orm.js").Extension<"res.compa
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
-    /** Its principal place of business: the seller's address on e-invoices and e-way bills. */
-    readonly street: import("../server/orm.js").CharField<{
-        readonly required: false;
-        readonly computed: false;
-        readonly inverse: false;
-        readonly sequence: false;
-        readonly computeName: undefined;
-        readonly store: true;
-        readonly hasDefault: false;
-        readonly readonly: false;
-    }, string>;
-    readonly city: import("../server/orm.js").CharField<{
-        readonly required: false;
-        readonly computed: false;
-        readonly inverse: false;
-        readonly sequence: false;
-        readonly computeName: undefined;
-        readonly store: true;
-        readonly hasDefault: false;
-        readonly readonly: false;
-    }, string>;
-    readonly zip: import("../server/orm.js").CharField<{
-        readonly required: false;
-        readonly computed: false;
-        readonly inverse: false;
-        readonly sequence: false;
-        readonly computeName: undefined;
-        readonly store: true;
-        readonly hasDefault: false;
-        readonly readonly: false;
-    }, string>;
     /** Customer invoices and notes are registered with the IRP when posted (turnover above the threshold). */
     readonly einvoiceEnabled: import("../server/orm.js").ScalarField<"boolean", boolean, boolean, {
         readonly required: true;
@@ -7506,37 +7475,6 @@ export declare const l10nInShutro: import("../server/orm.js").Module<readonly [i
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
-    /** Its principal place of business: the seller's address on e-invoices and e-way bills. */
-    readonly street: import("../server/orm.js").CharField<{
-        readonly required: false;
-        readonly computed: false;
-        readonly inverse: false;
-        readonly sequence: false;
-        readonly computeName: undefined;
-        readonly store: true;
-        readonly hasDefault: false;
-        readonly readonly: false;
-    }, string>;
-    readonly city: import("../server/orm.js").CharField<{
-        readonly required: false;
-        readonly computed: false;
-        readonly inverse: false;
-        readonly sequence: false;
-        readonly computeName: undefined;
-        readonly store: true;
-        readonly hasDefault: false;
-        readonly readonly: false;
-    }, string>;
-    readonly zip: import("../server/orm.js").CharField<{
-        readonly required: false;
-        readonly computed: false;
-        readonly inverse: false;
-        readonly sequence: false;
-        readonly computeName: undefined;
-        readonly store: true;
-        readonly hasDefault: false;
-        readonly readonly: false;
-    }, string>;
     /** Customer invoices and notes are registered with the IRP when posted (turnover above the threshold). */
     readonly einvoiceEnabled: import("../server/orm.js").ScalarField<"boolean", boolean, boolean, {
         readonly required: true;

package/dist/l10n_in/module.js

@@ -101,10 +101,8 @@ export const CompanyGst = extendModel('res.company', {
     fields: {
         gstin: f.char({ size: 15, label: 'GSTIN' }),
         pan: f.char({ size: 10, label: 'PAN' }),
-        /** Its principal place of business: the seller's address on e-invoices and e-way bills. */
-        street: f.char({ label: 'Address' }),
-        city: f.char({ label: 'City' }),
-        zip: f.char({ size: 6, label: 'PIN code' }),
+        // Its principal place of business (`street`, `city`, `zip`: the base's company address) is the seller's
+        // address on e-invoices and e-way bills.
         /** Customer invoices and notes are registered with the IRP when posted (turnover above the threshold). */
         einvoiceEnabled: f.boolean({ required: true, default: false, label: 'E-invoicing' }),
     },

package/dist/modules-sdk/index.d.ts

@@ -6,5 +6,5 @@ export { type AppChange, type AppPlan, AppPlanError, type AppReason, type AppSta
 export { idByName, maybeIdByName } from './demo.js';
 export { ModuleDefinitionError, ModuleLoadError } from './errors.js';
 export { type LoadedModules, type LoadOptions, loadModules } from './loader.js';
-export { type AccessLevel, type ApprovalLevelSpec, type ApprovalSpec, type AppSpec, type AutomationActionSpec, type AutomationRuleSpec, type DemoContext, type DemoUser, type DocumentSpec, defineModule, type ImportTemplateSpec, type InboundAliasSpec, type KoshModule, type LocalizationSpec, type MenuSpec, type ModuleHooks, type ModuleInput, type PortalActionSpec, type PortalDocumentSpec, type ShutroModuleShape, } from './manifest.js';
+export { type AccessLevel, type ApprovalLevelSpec, type ApprovalSpec, type AppSpec, type AutomationActionSpec, type AutomationRuleSpec, type DemoContext, type DemoUser, type DocumentSpec, defineModule, type EventSpec, type ImportTemplateSpec, type InboundAliasSpec, type InboundCall, type InboundWebhookSpec, type KoshModule, type LocalizationSpec, type MenuSpec, type ModuleHooks, type ModuleInput, type PortalActionSpec, type PortalDocumentSpec, type ShutroModuleShape, } from './manifest.js';
 export { compareVersions, satisfies } from './semver.js';