shutro-erp 0.3.1 → 0.3.2

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/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';

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

@@ -97,6 +97,43 @@ export interface AutomationRuleSpec {
     /** Installed switched on (default) or off. */
     readonly enabled?: boolean;
 }
+/**
+ * An event a module emits through Shutro's outbox (`env.emit(topic, { id, … })`), which webhooks and integrations
+ * may subscribe to (RFC 0017 §5.3): the topic, the model whose record `id` names, and what it means.
+ */
+export interface EventSpec {
+    readonly topic: string;
+    readonly model: string;
+    readonly label: string;
+}
+/** A call received by an inbound webhook (RFC 0017 §5.4): the raw body (what signatures cover) and its JSON. */
+export interface InboundCall {
+    readonly headers: Readonly<Record<string, string | undefined>>;
+    readonly query: Readonly<Record<string, string | undefined>>;
+    /** The body as received. */
+    readonly body: string;
+    /** The body parsed as JSON, or null. */
+    readonly json: unknown;
+}
+/**
+ * An endpoint a module receives calls on from outside (RFC 0017 §5.4): a payment provider's callback, a shipping
+ * status. Companies switch it on in Integrations › Inbound webhooks (a URL and a secret each).
+ */
+export interface InboundWebhookSpec {
+    /** Unique within the module (`ipn`); the endpoint is `<module>.<key>`. */
+    readonly key: string;
+    readonly label: string;
+    /**
+     * Whether the call is genuine — the provider's signature, or an HMAC with the endpoint's secret — and its event
+     * id, by which repeated calls are recognised: the id, or null to refuse the call.
+     */
+    readonly verify: (call: InboundCall, secret: string) => string | null | Promise<string | null>;
+    /**
+     * Handles a verified call, once per event id, in a job (retried on failure): `env` is a system environment in
+     * the endpoint's company. Returns a short note for the log (a string; anything else is not kept).
+     */
+    readonly handle: (env: unknown, call: InboundCall) => Promise<unknown>;
+}
 /** A default document template of a module. */
 export interface DocumentSpec {
     /** Unique within the module (`purchase_order`); stored as `module.key`. */
@@ -175,6 +212,13 @@ export interface PortalDocumentSpec {
      * email with a link, once. The model's writes must reach the portal: list it in the module's `changeEvents`.
      */
     readonly announce?: Readonly<Record<string, unknown>>;
+    /**
+     * The customer may pay it online (RFC 0017 §5.5) while it is in this domain (`{ paymentState: 'not_paid' }`):
+     * the document's page offers Pay now when a payment module and a provider are there.
+     */
+    readonly payment?: {
+        readonly when: Readonly<Record<string, unknown>>;
+    };
 }
 /**
  * A country localization (RFC 0016 §5.2): what installing it sets up for a company, once — its chart of accounts,
@@ -367,6 +411,10 @@ export interface ModuleInput {
     readonly externalGroups?: readonly string[];
     /** The country this module localizes (RFC 0016): set up for each company when the module is installed. */
     readonly localization?: LocalizationSpec;
+    /** Events the module emits that webhooks may subscribe to (RFC 0017 §5.3). */
+    readonly events?: readonly EventSpec[];
+    /** Endpoints the module receives calls on from outside (RFC 0017 §5.4). */
+    readonly inboundWebhooks?: readonly InboundWebhookSpec[];
     /** What the module shows in the customer and vendor portal (RFC 0015), when `portal` is installed. */
     readonly portal?: {
         readonly documents: readonly PortalDocumentSpec[];

package/dist/payment/.kosh/bindings.d.ts

@@ -0,0 +1,22 @@
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { type DefinitionHelpers } from '../../server/orm.js';
+import type { DefaultLoaded, Env as CoreEnv, RecordSet as CoreRecordSet, Shutro as CoreShutro } from '../../server/orm.js';
+import type { SchemaView } from './schema.js';
+export type { SchemaView };
+/** Every model visible in this view. */
+export type ModelName = keyof SchemaView & string;
+/** `Env` typed to this view. */
+export type Env = CoreEnv<SchemaView>;
+/** `Shutro` typed to this view. */
+export type Shutro = CoreShutro<SchemaView>;
+/** A recordset of `M`, with the default loaded shape unless `L` is given. */
+export type Records<M extends ModelName, L = DefaultLoaded<SchemaView, M>> = CoreRecordSet<SchemaView, M, L>;
+export declare const compute: DefinitionHelpers<SchemaView>['compute'];
+export declare const check: DefinitionHelpers<SchemaView>['check'];
+export declare const onchange: DefinitionHelpers<SchemaView>['onchange'];
+export declare const records: DefinitionHelpers<SchemaView>['records'];
+export declare const method: DefinitionHelpers<SchemaView>['method'];
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export declare const record: DefinitionHelpers<SchemaView>['record'];
+export declare const override: DefinitionHelpers<SchemaView>['override'];
+export declare const ref: DefinitionHelpers<SchemaView>['ref'];

package/dist/payment/.kosh/bindings.js

@@ -0,0 +1,15 @@
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 51b637962c6e5497
+// Bindings of module `payment`: 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';
+/** Definition callbacks typed against this module's view: no casts in computes, checks, onchange, methods. */
+const helpers = definitions();
+export const compute = helpers.compute;
+export const check = helpers.check;
+export const onchange = helpers.onchange;
+export const records = helpers.records;
+export const method = helpers.method;
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export const record = helpers.record;
+export const override = helpers.override;
+export const ref = helpers.ref;