@wirecat/cli-core 0.573.0 → 0.575.0

package/dist/index.js

@@ -6,6 +6,7 @@ export { formatLocator, isLocator, parseLocator } from "./domain/locator.js";
 export { parseMarkdown } from "./domain/markdown.js";
 export { parseMarkdownSpans } from "./domain/markdown-spans.js";
 export { CURRENCY_SCALES, currencyOf, minorUnits, moneyLabel, moneyOf, } from "./domain/money.js";
+export { ORDER_PURPOSES, ORDER_STATUSES, } from "./domain/orders.js";
 export { countedPoll } from "./domain/polls.js";
 export { FOLDER_PROVIDERS, isFolderProvider, isKind, KINDS, kindIn, kindOf, PROVIDERS, providerNamed, providers, UNKNOWN_PROVIDER, useProviders, } from "./domain/providers.js";
 export { rankingOptions } from "./domain/rankings-options.js";

package/dist/mail/findings.d.ts

@@ -1,4 +1,6 @@
+import { INVOICE_DIRECTIONS, MONEY_DIRECTIONS } from "../domain/finance.js";
 import { MEMORY_KINDS, MEMORY_SCOPES } from "../domain/knowledge.js";
+import { ORDER_PURPOSES, ORDER_STATUSES } from "../domain/orders.js";
 import { type FactFinding, type FindingEvidence, type TaskFinding } from "../meetings/index.js";
 export { MAIL_FINDINGS_KIND } from "../store/mail-findings.js";
 /** At most this many findings in one run's batch, and per sender in it. */
@@ -39,7 +41,77 @@ export interface MailNewContactFinding extends Cited {
     name: string;
     reason?: string;
 }
-export type MailFinding = MailTaskFinding | MailFactFinding | MailTaskUpdateFinding | MailMemoryFinding | MailLinkFinding | MailNewContactFinding;
+/** An invoice the mail carries; accepting it records the invoice through `store.finance`, confirmed. */
+export interface MailInvoiceFinding extends Cited {
+    kind: "invoice";
+    direction: (typeof INVOICE_DIRECTIONS)[number];
+    /** `person:` or `organization:`. */
+    counterparty: string;
+    currency: string;
+    lines: {
+        description: string;
+        quantity?: string;
+        unitPrice?: string;
+        amount?: string;
+    }[];
+    /** The total printed on it: the store refuses it unless it is the lines' sum. */
+    total?: string;
+    number?: string;
+    issueDate?: string;
+    dueDate?: string;
+    project?: string;
+    reason: string;
+}
+/** A payment the mail confirms, such as a receipt; accepting it records the payment through `store.finance`. */
+export interface MailPaymentFinding extends Cited {
+    kind: "payment";
+    direction: (typeof MONEY_DIRECTIONS)[number];
+    payer?: string;
+    payee?: string;
+    amount: string;
+    currency: string;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    /** The payment's own reference text, such as the receipt number. */
+    reference?: string;
+    /** Stored invoices it settles, in the payment's currency. */
+    allocations?: {
+        invoice: string;
+        amount: string;
+    }[];
+    project?: string;
+    reason: string;
+}
+/** An order the mail confirms; accepting it records the order through `store.orders`. */
+export interface MailOrderFinding extends Cited {
+    kind: "order";
+    purpose: (typeof ORDER_PURPOSES)[number];
+    /** Whom it is for; the owner when left out. */
+    customer?: string;
+    supplier?: string;
+    supplierName: string;
+    number?: string;
+    total?: string;
+    currency?: string;
+    status?: (typeof ORDER_STATUSES)[number];
+    orderDate?: string;
+    fulfilledDate?: string;
+    invoice?: string;
+    payment?: string;
+    project?: string;
+    reason: string;
+}
+/** A later mail about a stored order, found by its shop and number: shipped, delivered, cancelled, returned. */
+export interface MailOrderUpdateFinding extends Cited {
+    kind: "order_update";
+    supplierName: string;
+    number: string;
+    status: (typeof ORDER_STATUSES)[number];
+    /** `YYYY-MM-DD`, the delivery day of a delivered order. */
+    date?: string;
+    reason: string;
+}
+export type MailFinding = MailTaskFinding | MailFactFinding | MailTaskUpdateFinding | MailMemoryFinding | MailLinkFinding | MailNewContactFinding | MailInvoiceFinding | MailPaymentFinding | MailOrderFinding | MailOrderUpdateFinding;
 export interface MailFindingsInput {
     schemaVersion: 1;
     /** `<holder>:<through_id>`: one batch per run of a holder over the mail it was given. */

package/dist/mail/findings.js

@@ -1,6 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
+import { INVOICE_DIRECTIONS, MONEY_DIRECTIONS } from "../domain/finance.js";
 import { MEMORY_KINDS, MEMORY_SCOPES } from "../domain/knowledge.js";
 import { formatLocator, parseLocator } from "../domain/locator.js";
+import { ORDER_PURPOSES, ORDER_STATUSES } from "../domain/orders.js";
 import { parseReference } from "../domain/references.js";
 import { findingFields, findingHash, findingId, findingText, meetingTimestamp, validateBatch, validateFinding, validEvidence, } from "../meetings/index.js";
 export { MAIL_FINDINGS_KIND } from "../store/mail-findings.js";
@@ -42,6 +44,18 @@ const LINKS = {
     "chat:email": "project",
 };
 const ADDRESS = /^[^\s@<>]+@[^\s@<>]+$/;
+const PARTY = /^(person|organization):[1-9]\d*$/;
+const INVOICE = /^invoice:[1-9]\d*$/;
+const PAYMENT = /^payment:[1-9]\d*$/;
+const PROJECT = /^project:[1-9]\d*$/;
+const oneOf = (value, allowed, what) => {
+    if (typeof value !== "string" || !allowed.includes(value))
+        return invalid(`${what} is ${allowed.join(", ")}`);
+    return value;
+};
+/** Money and dates stay text here: the store's finance and order services check them as they check the owner's. */
+const word = (value, limit) => findingText(value, limit);
+const optional = (key, value, read) => (value === undefined ? {} : { [key]: read(value) });
 const one = (raw, ids) => {
     if (!raw || typeof raw !== "object")
         return invalid("a finding is an object");
@@ -123,8 +137,157 @@ const one = (raw, ids) => {
                 evidence,
             };
         }
+        case "invoice": {
+            findingFields(raw, [
+                "id",
+                "kind",
+                "direction",
+                "counterparty",
+                "currency",
+                "lines",
+                "total",
+                "number",
+                "issueDate",
+                "dueDate",
+                "project",
+                "reason",
+                "evidence",
+            ], RULES.singular);
+            if (!Array.isArray(raw.lines) || raw.lines.length < 1 || raw.lines.length > 50)
+                return invalid("an invoice finding has 1–50 lines");
+            const lines = raw.lines.map((line) => {
+                if (!line || typeof line !== "object")
+                    return invalid("an invoice line is an object");
+                const fields = line;
+                findingFields(fields, ["description", "quantity", "unitPrice", "amount"], "invoice line");
+                return {
+                    description: word(fields.description, 500),
+                    ...optional("quantity", fields.quantity, (value) => word(value, 20)),
+                    ...optional("unitPrice", fields.unitPrice, (value) => word(value, 30)),
+                    ...optional("amount", fields.amount, (value) => word(value, 30)),
+                };
+            });
+            return {
+                id,
+                kind: "invoice",
+                direction: oneOf(raw.direction, INVOICE_DIRECTIONS, "an invoice's direction"),
+                counterparty: reference(raw.counterparty, PARTY, "an invoice's counterparty"),
+                currency: word(raw.currency, 3),
+                lines,
+                ...optional("total", raw.total, (value) => word(value, 30)),
+                ...optional("number", raw.number, (value) => word(value, 80)),
+                ...optional("issueDate", raw.issueDate, (value) => word(value, 10)),
+                ...optional("dueDate", raw.dueDate, (value) => word(value, 10)),
+                ...optional("project", raw.project, (value) => reference(value, PROJECT, "a project")),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
+        case "payment": {
+            findingFields(raw, [
+                "id",
+                "kind",
+                "direction",
+                "payer",
+                "payee",
+                "amount",
+                "currency",
+                "date",
+                "reference",
+                "allocations",
+                "project",
+                "reason",
+                "evidence",
+            ], RULES.singular);
+            let allocations;
+            if (raw.allocations !== undefined) {
+                if (!Array.isArray(raw.allocations) || raw.allocations.length < 1 || raw.allocations.length > 8)
+                    return invalid("a payment finding's allocations are 1–8 invoices it settles");
+                allocations = raw.allocations.map((share) => {
+                    if (!share || typeof share !== "object")
+                        return invalid("an allocation is an invoice and an amount");
+                    const fields = share;
+                    findingFields(fields, ["invoice", "amount"], "allocation");
+                    return {
+                        invoice: reference(fields.invoice, INVOICE, "an allocation's invoice"),
+                        amount: word(fields.amount, 30),
+                    };
+                });
+            }
+            return {
+                id,
+                kind: "payment",
+                direction: oneOf(raw.direction, MONEY_DIRECTIONS, "a payment's direction"),
+                ...optional("payer", raw.payer, (value) => reference(value, PARTY, "a payment's payer")),
+                ...optional("payee", raw.payee, (value) => reference(value, PARTY, "a payment's payee")),
+                amount: word(raw.amount, 30),
+                currency: word(raw.currency, 3),
+                date: word(raw.date, 10),
+                ...optional("reference", raw.reference, (value) => word(value, 500)),
+                ...(allocations === undefined ? {} : { allocations }),
+                ...optional("project", raw.project, (value) => reference(value, PROJECT, "a project")),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
+        case "order": {
+            findingFields(raw, [
+                "id",
+                "kind",
+                "purpose",
+                "customer",
+                "supplier",
+                "supplierName",
+                "number",
+                "total",
+                "currency",
+                "status",
+                "orderDate",
+                "fulfilledDate",
+                "invoice",
+                "payment",
+                "project",
+                "reason",
+                "evidence",
+            ], RULES.singular);
+            return {
+                id,
+                kind: "order",
+                purpose: oneOf(raw.purpose, ORDER_PURPOSES, "an order's purpose"),
+                ...optional("customer", raw.customer, (value) => reference(value, PARTY, "an order's customer")),
+                ...optional("supplier", raw.supplier, (value) => reference(value, PARTY, "an order's supplier")),
+                supplierName: word(raw.supplierName, 200),
+                ...optional("number", raw.number, (value) => word(value, 80)),
+                ...optional("total", raw.total, (value) => word(value, 30)),
+                ...optional("currency", raw.currency, (value) => word(value, 3)),
+                ...optional("status", raw.status, (value) => oneOf(value, ORDER_STATUSES, "an order's status")),
+                ...optional("orderDate", raw.orderDate, (value) => word(value, 10)),
+                ...optional("fulfilledDate", raw.fulfilledDate, (value) => word(value, 10)),
+                ...optional("invoice", raw.invoice, (value) => reference(value, INVOICE, "an order's invoice")),
+                ...optional("payment", raw.payment, (value) => reference(value, PAYMENT, "an order's payment")),
+                ...optional("project", raw.project, (value) => reference(value, PROJECT, "a project")),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
+        case "order_update": {
+            findingFields(raw, ["id", "kind", "supplierName", "number", "status", "date", "reason", "evidence"], RULES.singular);
+            const status = oneOf(raw.status, ORDER_STATUSES, "an order update's status");
+            if (raw.date !== undefined && status !== "delivered")
+                return invalid("only a delivered order update gives date");
+            return {
+                id,
+                kind: "order_update",
+                supplierName: word(raw.supplierName, 200),
+                number: word(raw.number, 80),
+                status,
+                ...optional("date", raw.date, (value) => word(value, 10)),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
         default:
-            return invalid("a mail finding is a task, task_update, fact, memory, link or new_contact");
+            return invalid("a mail finding is a task, task_update, fact, memory, link, new_contact, invoice, payment, order or order_update");
     }
 };
 /**

package/dist/models/openai.js

@@ -1,4 +1,5 @@
 import * as v from "valibot";
+import { withTimeLimit } from "../http/time-limit.js";
 import { checkedOptions, range } from "./options.js";
 import { messagesFor, systemFor } from "./types.js";
 const options = v.strictObject({
@@ -14,7 +15,7 @@ export const openai = {
     images: true,
     baseUrl: "https://api.openai.com/v1",
     validate: (given) => checkedOptions("openai", options, given),
-    complete: async (target, request, checked, apiKey, fetcher) => {
+    complete: (target, request, checked, apiKey, fetcher) => withTimeLimit(120_000, async (deadline) => {
         const response = await fetcher(`${target.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
             method: "POST",
             headers: { "Content-Type": "application/json", ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}) },
@@ -40,7 +41,7 @@ export const openai = {
                     ? { max_completion_tokens: request.maxTokens }
                     : { max_tokens: request.maxTokens }),
             }),
-            signal: AbortSignal.timeout(120_000),
+            signal: deadline,
             redirect: "error",
         });
         if (!response.ok)
@@ -53,5 +54,5 @@ export const openai = {
             (body.usage?.total_tokens ?? 0) < 1)
             throw new Error("incomplete response");
         return { text: choice.message.content, tokens: body.usage?.total_tokens };
-    },
+    }),
 };

package/dist/oauth/requests.js

@@ -1,4 +1,5 @@
 import { CliError, isCliError } from "@wirecat/cli-base";
+import { withTimeLimit } from "../http/time-limit.js";
 const REQUEST_LIMIT_MS = 30_000;
 export const TOKEN_LOG_EVENT = "oauth.token";
 /** The keys the module's log records carry, for a run log's `allow`; names only, never a token. */
@@ -8,20 +9,20 @@ const object = (value) => {
         throw new Error("not an object");
     return value;
 };
-const requestSignal = (signal) => signal ? AbortSignal.any([signal, AbortSignal.timeout(REQUEST_LIMIT_MS)]) : AbortSignal.timeout(REQUEST_LIMIT_MS);
+const requestSignal = (deadline, signal) => signal ? AbortSignal.any([signal, deadline]) : deadline;
 const cancelledBy = (signal) => {
     if (!signal?.aborted)
         return;
     throw isCliError(signal.reason) ? signal.reason : new CliError("cancelled", "sign-in was cancelled");
 };
-const post = async (url, body, context) => {
+const post = async (url, body, context, deadline) => {
     cancelledBy(context.signal);
     try {
         return await context.fetch(url, {
             method: "POST",
             headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
             body,
-            signal: requestSignal(context.signal),
+            signal: requestSignal(deadline, context.signal),
             redirect: "error",
         });
     }
@@ -38,11 +39,12 @@ const clientFields = ({ client }) => ({
  * The token endpoint, form-encoded, for both grants. Nothing from the request or the response reaches a message or
  * a log record: both carry codes and tokens.
  */
-export const requestTokens = async (provider, params, context) => {
+export const requestTokens = (provider, params, context) => withTimeLimit(REQUEST_LIMIT_MS, (deadline) => exchangeTokens(provider, params, context, deadline));
+const exchangeTokens = async (provider, params, context, deadline) => {
     const operation = params.grant_type ?? "unknown";
     const record = (level, fields) => context.log?.[level]({ event: TOKEN_LOG_EVENT, provider: provider.id, operation, pid: process.pid, ...fields });
     const again = `run ${context.signInCommand} again`;
-    const response = await post(provider.tokenUrl, new URLSearchParams({ ...params, ...clientFields(context) }), context);
+    const response = await post(provider.tokenUrl, new URLSearchParams({ ...params, ...clientFields(context) }), context, deadline);
     if (!response) {
         record("warn", { outcome: "no_response" });
         throw new CliError("outcome_unknown", `${provider.name} token request did not finish; ${again} if it keeps failing`, {
@@ -112,7 +114,9 @@ export const revokeToken = async (provider, tokens, context) => {
         return provider.revoke(tokens, context);
     if (!provider.revokeUrl)
         throw new CliError("validation_error", `${provider.name} declares no way to revoke a sign-in`);
-    const response = await post(provider.revokeUrl, new URLSearchParams({ token: tokens.refreshToken, ...clientFields(context) }), context);
+    const { revokeUrl } = provider;
+    const form = new URLSearchParams({ token: tokens.refreshToken, ...clientFields(context) });
+    const response = await withTimeLimit(REQUEST_LIMIT_MS, (deadline) => post(revokeUrl, form, context, deadline));
     context.log?.[response?.ok ? "info" : "warn"]({
         event: TOKEN_LOG_EVENT,
         provider: provider.id,

package/dist/services/proposals/kinds/mail-findings.js

@@ -1,5 +1,6 @@
 import { MAIL_FINDINGS_KIND } from "../../../store/index.js";
 import { kept, proposerOfAuthor } from "./shared.js";
+const words = (...parts) => parts.filter(Boolean).join(" ");
 /** A finding's one line in the inbox; never the email's text, only what the agent wrote. */
 const summaryOf = (finding) => {
     switch (finding.kind) {
@@ -15,6 +16,14 @@ const summaryOf = (finding) => {
             return `${finding.from} → ${finding.to}`;
         case "new_contact":
             return `${finding.name} <${finding.address}>`;
+        case "invoice":
+            return words("invoice", finding.number, finding.total, finding.currency, `· ${finding.reason}`);
+        case "payment":
+            return words("payment", finding.amount, finding.currency, finding.date, `· ${finding.reason}`);
+        case "order":
+            return words("order", finding.number, finding.supplierName, finding.status ?? "placed", `· ${finding.reason}`);
+        case "order_update":
+            return words("order", finding.number, finding.supplierName, finding.status, `· ${finding.reason}`);
     }
 };
 const rowOf = (batch, createdAt) => {

package/dist/services/proposals/kinds/orders.d.ts

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** An agent's order, by its own ref (`order:12`) as invoices are; only the owner decides it. */
+export declare const orderKind: (store: Pick<MessageStore, "orders">) => ProposalKind;

package/dist/services/proposals/kinds/orders.js

@@ -0,0 +1,32 @@
+import { kept, proposerOfAuthor, pushed } from "./shared.js";
+const rowOf = (order) => ({
+    id: order.ref,
+    kind: "order",
+    status: order.review,
+    project: order.project,
+    subject: order.ref,
+    object: order.supplier?.ref ?? null,
+    summary: order.title,
+    proposedBy: proposerOfAuthor(order.author),
+    reason: order.reason,
+    evidence: [],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: order.createdAt,
+});
+/** An agent's order, by its own ref (`order:12`) as invoices are; only the owner decides it. */
+export const orderKind = (store) => ({
+    kind: "order",
+    prefix: "order",
+    list: async (filter) => {
+        const status = filter.status ?? "proposed";
+        const orders = await store.orders.list({ ...pushed(filter), ...(status === "all" ? {} : { review: status }) });
+        return kept(orders.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.orders.get(id)),
+    decide: async (id, { confirm, by, reason }) => {
+        const order = confirm ? await store.orders.confirm(id, by, reason) : await store.orders.reject(id, by, reason);
+        return { id, kind: "order", status: confirm ? "confirmed" : "rejected", made: confirm ? [order.ref] : [] };
+    },
+});

package/dist/services/proposals/registry.js

@@ -8,6 +8,7 @@ import { keyDocumentKind } from "./kinds/key-document.js";
 import { mailFindingsKind } from "./kinds/mail-findings.js";
 import { meetingFindingsKind } from "./kinds/meeting-findings.js";
 import { memoryKind } from "./kinds/memory.js";
+import { orderKind } from "./kinds/orders.js";
 import { relationshipKind } from "./kinds/relationship.js";
 import { relationshipUpdateKind } from "./kinds/relationship-update.js";
 import { taskCloseKind } from "./kinds/task-close.js";
@@ -132,6 +133,7 @@ export const proposalRegistry = (store) => {
         factKind(store),
         invoiceKind(store),
         paymentKind(store),
+        orderKind(store),
         memoryKind(store),
         findingsKind(store),
         mailFindingsKind(store),

package/dist/store/index.d.ts

@@ -53,6 +53,7 @@ export type { Author, MemoriesStore, Memory, MemoryInput } from "./sqlite/memori
 export type { NoteIndexState } from "./sqlite/note-index.js";
 export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, type NoteQuery, type NoteSearch, } from "./sqlite/note-search.js";
 export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
+export type { Order, OrderFilter, OrderInput, OrdersStore } from "./sqlite/orders.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export { assertGenericAction, PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
 export type { RecordKey, RecordOutcome, RecordStore, RecordsWritten, SourceRecord, } from "./sqlite/records.js";

package/dist/store/sqlite/entity-types.d.ts

@@ -27,6 +27,7 @@ export declare const ENTITY_TABLES: {
     readonly memory: "memories";
     readonly message: "messages";
     readonly note: "notes";
+    readonly order: "orders";
     readonly organization: "organizations";
     readonly payment: "payments";
     readonly person: "persons";

package/dist/store/sqlite/entity-types.js

@@ -26,6 +26,7 @@ export const ENTITY_TABLES = {
     memory: "memories",
     message: "messages",
     note: "notes",
+    order: "orders",
     organization: "organizations",
     payment: "payments",
     person: "persons",

package/dist/store/sqlite/finance.d.ts

@@ -11,7 +11,7 @@ export interface Party {
     /** The owner's own person row. */
     owner: boolean;
 }
-interface Reviewed {
+export interface Reviewed {
     review: FinanceReview;
     /** `name` is a bot's handle and `kind` whether it is an agent or a rule; both `null` for a person. */
     author: {
@@ -91,7 +91,7 @@ export interface Payment extends Reviewed {
 export interface PaymentDetail extends Payment {
     allocations: Allocation[];
 }
-interface Written {
+export interface Written {
     /** The owner's entry is confirmed at once; a bot's waits as proposed for the owner. */
     by: Author;
     project?: string;
@@ -204,6 +204,44 @@ export interface FinanceStore {
         payable: OpenTotal[];
     }>;
 }
+type Row = Record<string, unknown>;
+export declare const refuse: (message: string, reason: string, code?: "validation_error" | "permission_error") => never;
+export declare const oneOf: <T extends string>(value: unknown, allowed: readonly T[], what: string) => T;
+export declare const text: (value: unknown, what: string, limit: number) => string | null;
+export declare const isoDate: (value: unknown, what: string) => string | null;
+export declare const iso: (value: unknown) => string;
+/** What invoices, payments and orders share: their parties, who wrote them, and how the owner decides them. */
+export declare const reviewedRowsOver: (context: StoreContext) => {
+    partyOf: (type: unknown, id: unknown) => Party | null;
+    partyThing: (reference: string | undefined, what: string) => import("./things.js").Thing | undefined;
+    reviewedOf: (row: Row, type: "invoice" | "payment" | "order") => Reviewed;
+    written: (input: Written) => {
+        owner: boolean;
+        actor: Actor;
+        model: string | null;
+        source: string;
+        review: string;
+        confirmedType: "bot" | "person" | null;
+        confirmedId: number | null;
+        metadata: string | null;
+        project: number | null;
+        evidence: string[];
+    };
+    keepEvidence: (type: "invoice" | "payment" | "order", id: number, by: ReturnType<(input: Written) => {
+        owner: boolean;
+        actor: Actor;
+        model: string | null;
+        source: string;
+        review: string;
+        confirmedType: "bot" | "person" | null;
+        confirmedId: number | null;
+        metadata: string | null;
+        project: number | null;
+        evidence: string[];
+    }>) => void;
+    ownerOnly: (by: Author, what: string) => void;
+    keepDecision: (table: "invoices" | "payments" | "orders", id: number, by: Decider, reason?: string) => void;
+};
 type FinanceOperations = {
     [K in keyof FinanceStore]: FinanceStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
 };