@copilotz/billing 0.0.0-stage → 1.0.0-rc.35

package/mod.js

@@ -0,0 +1,25 @@
+/**
+ * Billing (`@copilotz/billing`): what an org has to spend, and paying for it,
+ * built on Copilotz's usage ledger (`usage`, in `copilotz/plugins/billing`),
+ * whose prices it counts.
+ *
+ * - `credits`: an org's plan, credits and payments, its balance and budget,
+ *   and the check that stops it at its limit (the `spending` resource
+ *   whatever spends reads); staff change plans and give credits by hand.
+ * - `stripe`: one way an org pays, by Stripe's Checkout and portal; what was
+ *   paid lands by a signed webhook (`stripeWebhook`, in the runtime of the
+ *   app's one address: the directory's, with many orgs).
+ *
+ * ```ts
+ * import { usage } from "copilotz/plugins/billing";
+ * import { credits, stripe, stripeWebhook } from "@copilotz/billing";
+ *
+ * plugins: [models, chat, usage, credits, stripe, stripeWebhook, …]
+ * ```
+ *
+ * Their front end is `@copilotz/billing/web` (`creditsWeb`: the org page's
+ * Billing, the note above where you type); their shapes,
+ * `@copilotz/billing/contract`.
+ */
+export * from "./credits/mod.js";
+export { API_VERSION, EVENTS, stripe, stripeWebhook } from "./stripe/mod.js";

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@copilotz/billing",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-rc.35",
+  "description": "What an org has to spend (credits, plans, budgets) and paying for it with Stripe, on Copilotz's usage ledger. A Copilotz plugin.",
+  "keywords": [
+    "copilotz",
+    "agents",
+    "ai",
+    "plugin"
+  ],
+  "homepage": "https://github.com/copilotzhq/copilotz/tree/main/packages/billing#readme",
+  "bugs": "https://github.com/copilotzhq/copilotz/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/copilotzhq/copilotz.git",
+    "directory": "packages/billing"
+  },
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "types": "./mod.d.ts",
+  "exports": {
+    ".": {
+      "types": "./mod.d.ts",
+      "default": "./mod.js"
+    },
+    "./web": {
+      "types": "./web.d.ts",
+      "default": "./web.js"
+    },
+    "./contract": {
+      "types": "./contract.d.ts",
+      "default": "./contract.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "contract.d.ts",
+    "contract.js",
+    "credits",
+    "mod.d.ts",
+    "mod.js",
+    "stripe",
+    "web.d.ts",
+    "web.js"
+  ],
+  "dependencies": {},
+  "peerDependencies": {
+    "@types/react": "^19.3.0",
+    "copilotz": "1.0.0-rc.35",
+    "react": "^19.3.1"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  }
+}

package/stripe/actions/checkout.d.ts

@@ -0,0 +1,4 @@
+export declare const checkoutAction: import("copilotz").ActionDef;
+export declare const sellableAction: import("copilotz").ActionDef;
+export declare const portalAction: import("copilotz").ActionDef;
+export declare const seatsAction: import("copilotz").ActionDef;

package/stripe/actions/checkout.js

@@ -0,0 +1,188 @@
+/**
+ * Paying, as owners and admins of an org do, in person. Each answers `{ url }`,
+ * a page of Stripe's: card details never reach the app.
+ *
+ * - `billing.checkout` `{ credits, country? }`: buy credits, once (USD);
+ * - `billing.checkout` `{ plan, country? }`: subscribe to a plan, a seat each;
+ * - `billing.portal` `{}`: manage what's being paid: card, invoices, cancelling.
+ * - `billing.sellable` `{}`: the plans the org's seller has a price for, so
+ *   the Billing page offers only those (credits' `pay.sellable`).
+ *
+ * What was bought lands by the webhook, not here: a person can close the page,
+ * and only the webhook is signed.
+ */
+import { defineAction, failure, forbidden, inPerson, invalid } from "copilotz";
+import { runsOrg } from "copilotz/plugins/access/contract";
+import { billableSeats, orgKind, unfit, } from "../../credits/contract.js";
+import { stripeCall } from "../shared/api.js";
+import { sellerFor, settingsOf } from "../shared/settings.js";
+async function runsIt(ctx) {
+    if (ctx.actor?.staff === true)
+        return;
+    const me = await ctx.call("org.me", {});
+    if (!runsOrg(me.role))
+        throw forbidden("Only the org's owners and admins do this.");
+}
+const planOf = (ctx) => ctx.as().call("billing.plan", {});
+/** A plan as going live leaves it: a test mode's customer and subscription mean nothing there. */
+function fresh(set, plan) {
+    if (!set.live || !plan.sandbox)
+        return plan;
+    const { customer: _c, subscription: _s, seller: _l, status: _t, ...rest } = plan;
+    return rest;
+}
+const orgOf = (ctx) => {
+    const org = ctx.resources.org;
+    if (!org?.id)
+        throw invalid("This app doesn't sell by org.");
+    return org.id;
+};
+export const checkoutAction = defineAction({
+    description: "A page where the org buys credits, or subscribes to a plan",
+    record: false,
+    input: {
+        type: "object",
+        properties: {
+            credits: { type: "number", exclusiveMinimum: 0 },
+            plan: { type: "string" },
+            country: { type: "string", minLength: 2, maxLength: 2 },
+        },
+        additionalProperties: false,
+    },
+    allow: inPerson,
+    run: async (ctx, input) => {
+        await runsIt(ctx);
+        const org = orgOf(ctx);
+        const set = settingsOf(ctx);
+        const billing = ctx.resources.billing;
+        // With limits off nothing's for sale yet; staff can try it.
+        if (billing.enforce === false && ctx.actor?.staff !== true) {
+            throw failure("not_yet", "Nothing is charged for here yet.");
+        }
+        const plan = fresh(set, await planOf(ctx));
+        const chosen = sellerFor(set, plan.seller, input.country);
+        if (!chosen)
+            throw failure("no_seller", "Paying isn't set up here yet.");
+        const [name, seller] = chosen;
+        const back = (paid) => `${set.url}/org?tab=billing&paid=${paid}`;
+        const common = {
+            ...(plan.customer ? { customer: plan.customer } : {}),
+            client_reference_id: org,
+            cancel_url: `${set.url}/org?tab=billing`,
+        };
+        const call = (params) => stripeCall({ key: seller.key, fetch: ctx.fetch }, "POST", "/v1/checkout/sessions", {
+            ...common,
+            ...params,
+        });
+        if (input.plan) {
+            const terms = billing.plans[input.plan];
+            const price = seller.prices[input.plan];
+            if (!terms || !price)
+                throw invalid(`The plan "${input.plan}" can't be bought here.`);
+            const why = unfit(terms, orgKind(ctx));
+            if (why)
+                throw invalid(why);
+            if (plan.subscription && plan.status !== "canceled") {
+                throw failure("subscribed", "This org already has a subscription: manage it instead.");
+            }
+            // What the Billing page said it would come to: those not waived.
+            const people = await ctx.as().call("org.seats", {}).catch(() => 1);
+            const seats = billableSeats(plan, Math.max(people, 1), new Date().toISOString());
+            if (!seats)
+                throw failure("waived", "This org's seats are waived: there's nothing to pay.");
+            const metadata = { org, plan: input.plan, seller: name };
+            const { url } = await call({
+                mode: "subscription",
+                integration_identifier: "compass_plan_qwhtzkvb",
+                line_items: [{ price, quantity: seats }],
+                allow_promotion_codes: true,
+                metadata,
+                subscription_data: { metadata },
+                success_url: back("plan"),
+            });
+            return { url };
+        }
+        if (!input.credits)
+            throw invalid("Say how many credits.");
+        const credits = Math.round(input.credits * 100) / 100;
+        if (credits < billing.topUpMin || credits > billing.topUpMax) {
+            throw invalid(`Choose between $${billing.topUpMin} and $${billing.topUpMax}.`);
+        }
+        if (seller.currency !== "usd" && !seller.rate) {
+            throw failure("no_seller", "Paying isn't set up here yet.");
+        }
+        const unit = Math.ceil(credits / (seller.rate ?? 1) * 100);
+        const metadata = { org, purpose: "credits", credits: String(credits), seller: name };
+        const { url } = await call({
+            mode: "payment",
+            integration_identifier: "compass_credits_nmrplsjd",
+            line_items: [{
+                    quantity: 1,
+                    price_data: { currency: seller.currency, unit_amount: unit, product: seller.credits },
+                }],
+            ...(plan.customer ? {} : { customer_creation: "always" }),
+            metadata,
+            payment_intent_data: { metadata },
+            success_url: back("credits"),
+        });
+        return { url };
+    },
+});
+export const sellableAction = defineAction({
+    description: "The plans the org's seller can sell it",
+    record: false,
+    input: { type: "object", additionalProperties: false },
+    run: async (ctx) => {
+        const set = settingsOf(ctx);
+        // As checkout would choose: the seller it pays already, else the app's.
+        const had = await ctx.as().db.collection("billingPlan").findOne({ _id: "plan" });
+        const chosen = sellerFor(set, had ? fresh(set, had).seller : undefined);
+        return chosen ? Object.keys(chosen[1].prices) : [];
+    },
+});
+export const portalAction = defineAction({
+    description: "A page where the org manages what it pays: card, invoices, cancelling",
+    record: false,
+    input: { type: "object", additionalProperties: false },
+    allow: inPerson,
+    run: async (ctx) => {
+        await runsIt(ctx);
+        const set = settingsOf(ctx);
+        const plan = fresh(set, await planOf(ctx));
+        const chosen = sellerFor(set, plan.seller);
+        if (!chosen || !plan.customer) {
+            throw failure("not_paying", "There's nothing to manage yet: nothing has been paid.");
+        }
+        const { url } = await stripeCall({ key: chosen[1].key, fetch: ctx.fetch }, "POST", "/v1/billing_portal/sessions", {
+            customer: plan.customer,
+            return_url: `${set.url}/org?tab=billing`,
+            ...(chosen[1].portal ? { configuration: chosen[1].portal } : {}),
+        });
+        return { url };
+    },
+});
+export const seatsAction = defineAction({
+    description: "Brings a subscription's seats to the org's people, each day",
+    input: { type: "object", additionalProperties: false },
+    run: async (ctx) => {
+        const set = settingsOf(ctx);
+        const plan = await ctx.as().db.collection("billingPlan").findOne({ _id: "plan" });
+        if (!plan?.subscription || plan.status !== "active" || !plan.seller)
+            return {};
+        const seller = set.sellers[plan.seller];
+        if (!seller)
+            return {};
+        const people = await ctx.as().call("org.seats", {}).catch(() => 1);
+        const seats = billableSeats(plan, people, new Date().toISOString());
+        // Every seat waived: staff decide what happens to its subscription.
+        if (!seats)
+            return {};
+        const key = { key: seller.key, fetch: ctx.fetch };
+        const subscription = await stripeCall(key, "GET", `/v1/subscriptions/${plan.subscription}`);
+        const item = subscription.items.data[0];
+        if (!item || item.quantity === seats)
+            return {};
+        await stripeCall(key, "POST", `/v1/subscription_items/${item.id}`, { quantity: seats });
+        return { seats };
+    },
+});

package/stripe/actions/fact.d.ts

@@ -0,0 +1 @@
+export declare const factAction: import("copilotz").ActionDef;

package/stripe/actions/fact.js

@@ -0,0 +1,39 @@
+/**
+ * `stripe.fact` `{ seller, event }`: what an event Stripe sent (its
+ * signature already checked, by the webhook's route) comes to for an org, as
+ * facts for `billing.apply`: `{ fact }`, or `{ fact: null }` when it isn't
+ * ours (another product on the account) or keeps nothing. A dispute's
+ * charge is asked of Stripe (through `ctx.fetch`). The plan an org goes back
+ * to when its subscription ends is `billing.start` ("free" unless the app
+ * says). The system's, and unrecorded: its input is Stripe's event, and what
+ * it comes to lands in the org, as `billing.apply`, under the event's id.
+ */
+import { defineAction, invalid } from "copilotz";
+import { stripeCall } from "../shared/api.js";
+import { factOf, factOfDispute } from "../shared/events.js";
+import { settingsOf } from "../shared/settings.js";
+export const factAction = defineAction({
+    description: "What a Stripe event comes to for an org: facts for billing.apply, or none",
+    record: false,
+    input: {
+        type: "object",
+        properties: { seller: { type: "string" }, event: { type: "object" } },
+        required: ["seller", "event"],
+        additionalProperties: false,
+    },
+    run: async (ctx, input) => {
+        const seller = settingsOf(ctx).sellers[input.seller];
+        if (!seller)
+            throw invalid(`No seller "${input.seller}"`);
+        // deno-lint-ignore no-explicit-any
+        const event = input.event;
+        const named = { name: input.seller, ...(seller.rate ? { rate: seller.rate } : {}) };
+        const start = ctx.resources.billing?.start ?? "free";
+        if (event.type === "charge.dispute.created" || event.type === "charge.dispute.closed") {
+            const dispute = event.data.object;
+            const charge = await stripeCall({ key: seller.key, fetch: ctx.fetch }, "GET", `/v1/charges/${typeof dispute.charge === "string" ? dispute.charge : dispute.charge.id}`);
+            return { fact: factOfDispute(event.type, dispute, charge, named) };
+        }
+        return { fact: factOf(event, named, start) };
+    },
+});

package/stripe/mod.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Stripe: one way an org pays, for `credits`, which never asks it anything.
+ * Checkout and the customer portal are Stripe's pages, so no card reaches the
+ * app; what was paid lands by a signed webhook (`stripeWebhook`, its route
+ * `POST /__stripe/<seller>`: routes/webhook.ts), as `billing.apply`.
+ * One or more accounts sell (`sellers`): an org stays with whichever first took
+ * its money, chosen by its billing country. A plan is offered to an org only
+ * once its seller has a price for it (`billing.sellable`).
+ *
+ *   plugins: [usage, credits, stripe, stripeWebhook, …]
+ *   resources: { stripe: { url, seller: "main", sellers: { main: { key, … } } } }
+ *
+ * With many orgs, the webhook is the directory's (one address per account),
+ * and finds each org's runtime in the app's orgs:
+ *
+ *   directory's plugins: [identity, directory, stripeWebhook, …]
+ *   resources: { stripe: { ...stripeSettings, orgs } }
+ */
+import { type Plugin } from "copilotz";
+export { EVENTS } from "./shared/events.js";
+export { API_VERSION } from "./shared/api.js";
+export type { Seller, StripeSettings } from "./shared/settings.js";
+export declare const stripe: Plugin;
+/**
+ * Stripe's webhook, `POST /__stripe/<seller>`, where the app's accounts send
+ * their events (see routes/webhook.ts): in the runtime of the app's one
+ * address (the directory's, with many orgs), beside the `stripe` resource.
+ */
+export declare const stripeWebhook: Plugin;
+export default stripe;

package/stripe/mod.js

@@ -0,0 +1,52 @@
+/**
+ * Stripe: one way an org pays, for `credits`, which never asks it anything.
+ * Checkout and the customer portal are Stripe's pages, so no card reaches the
+ * app; what was paid lands by a signed webhook (`stripeWebhook`, its route
+ * `POST /__stripe/<seller>`: routes/webhook.ts), as `billing.apply`.
+ * One or more accounts sell (`sellers`): an org stays with whichever first took
+ * its money, chosen by its billing country. A plan is offered to an org only
+ * once its seller has a price for it (`billing.sellable`).
+ *
+ *   plugins: [usage, credits, stripe, stripeWebhook, …]
+ *   resources: { stripe: { url, seller: "main", sellers: { main: { key, … } } } }
+ *
+ * With many orgs, the webhook is the directory's (one address per account),
+ * and finds each org's runtime in the app's orgs:
+ *
+ *   directory's plugins: [identity, directory, stripeWebhook, …]
+ *   resources: { stripe: { ...stripeSettings, orgs } }
+ */
+import { definePlugin } from "copilotz";
+import { checkoutAction, portalAction, seatsAction, sellableAction } from "./actions/checkout.js";
+import { factAction } from "./actions/fact.js";
+import { webhookRoute } from "./routes/webhook.js";
+export { EVENTS } from "./shared/events.js";
+export { API_VERSION } from "./shared/api.js";
+export const stripe = definePlugin({
+    name: "stripe",
+    requires: ["credits"],
+    actions: {
+        "billing.checkout": checkoutAction,
+        "billing.portal": portalAction,
+        "billing.sellable": sellableAction,
+        "stripe.seats": seatsAction,
+    },
+    schedules: { "stripe.seats": { cron: "40 0 * * *", call: "stripe.seats", input: {} } },
+    resources: {
+        billing: {
+            pay: { checkout: "billing.checkout", portal: "billing.portal", sellable: "billing.sellable" },
+        },
+    },
+});
+/**
+ * Stripe's webhook, `POST /__stripe/<seller>`, where the app's accounts send
+ * their events (see routes/webhook.ts): in the runtime of the app's one
+ * address (the directory's, with many orgs), beside the `stripe` resource.
+ */
+export const stripeWebhook = definePlugin({
+    name: "stripe-webhook",
+    actions: { "stripe.fact": factAction },
+    routes: { "/__stripe/:seller": webhookRoute },
+    resources: { stripe: {} },
+});
+export default stripe;

package/stripe/routes/webhook.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Stripe's webhook, `POST /__stripe/<seller>`: the address each account's
+ * dashboard sends its events to, one for every org, so it's the app's (in
+ * an app of many orgs, the directory's runtime). The signature is checked
+ * against that seller's secret, on the raw text; the event read as facts
+ * (`stripe.fact`); and handed to its org's runtime as `billing.apply`, under
+ * the event's own id, so an event sent twice answers from the org's log.
+ *
+ * Which runtime is the org's: the app's orgs (`stripe.orgs`, the directory's
+ * `runtimes`), opened if it has to be; without them, this runtime, when the
+ * event is for its org (`resources.org`). Anything that can be tried again
+ * answers 500, and Stripe does; what never can (no such org, an event not
+ * ours, a plan the app no longer has) answers 200.
+ */
+import type { Route } from "copilotz";
+export declare const webhookRoute: Route;

package/stripe/routes/webhook.js

@@ -0,0 +1,56 @@
+import { verified } from "../shared/events.js";
+import { settingsOf } from "../shared/settings.js";
+const answer = (status, body = {}) => new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json", "cache-control": "no-store" },
+});
+export const webhookRoute = async (request, { runtime, params }) => {
+    if (request.method !== "POST")
+        return answer(405, { error: "Only POST" });
+    const resources = runtime.describe().resources;
+    const settings = settingsOf({ resources });
+    const name = decodeURIComponent(params.seller);
+    const seller = Object.hasOwn(settings.sellers, name) ? settings.sellers[name] : undefined;
+    if (!seller)
+        return answer(404, { error: "No such seller" });
+    const payload = await request.text();
+    if (!await verified(seller.webhookSecret, payload, request.headers.get("stripe-signature"))) {
+        return answer(400, { error: "Bad signature" });
+    }
+    let event;
+    try {
+        event = JSON.parse(payload);
+    }
+    catch {
+        return answer(400, { error: "Not JSON" });
+    }
+    try {
+        const { fact } = await runtime.call("stripe.fact", {
+            seller: name,
+            event,
+        });
+        // Not ours (another product on the account), or nothing to keep: received all the same.
+        if (!fact)
+            return answer(200, { ignored: event.type });
+        const own = resources.org?.id;
+        const target = settings.orgs
+            ? await settings.orgs.get(fact.org)
+            : own === fact.org
+                ? runtime
+                : undefined;
+        // An org that's gone won't come back, so there's nothing to try again.
+        if (!target)
+            return answer(200, { ignored: "no such org" });
+        const { org: _, ...facts } = fact;
+        await target.call("billing.apply", facts, { id: `stripe:${event.id}` });
+        return answer(200);
+    }
+    catch (error) {
+        console.error(`stripe: ${event.type} (${event.id}):`, error instanceof Error ? error.message : error);
+        // What can never land (a plan the app no longer has) isn't worth trying again.
+        if (error.code === "invalid") {
+            return answer(200, { ignored: "invalid" });
+        }
+        return answer(500, { error: "Try again" });
+    }
+};

package/stripe/shared/api.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Calling Stripe: its REST API over `fetch`, with no package to carry, on one
+ * API version. Parameters go form-encoded, nested as `a[b][0]=c`.
+ */
+export declare const API_VERSION = "2026-10-28.endive";
+type Params = Record<string, unknown>;
+/** `{ a: { b: [1] } }` as `a[b][0]=1`; what's undefined is left out. */
+export declare function encode(params: Params, prefix?: string): [string, string][];
+export declare function stripeCall<R = Record<string, unknown>>(options: {
+    key: string;
+    fetch: typeof fetch;
+    idempotency?: string;
+}, method: "GET" | "POST", path: string, params?: Params): Promise<R>;
+export {};

package/stripe/shared/api.js

@@ -0,0 +1,42 @@
+/**
+ * Calling Stripe: its REST API over `fetch`, with no package to carry, on one
+ * API version. Parameters go form-encoded, nested as `a[b][0]=c`.
+ */
+export const API_VERSION = "2026-10-28.endive";
+const BASE = "https://api.stripe.com";
+/** `{ a: { b: [1] } }` as `a[b][0]=1`; what's undefined is left out. */
+export function encode(params, prefix = "") {
+    return Object.entries(params).flatMap(([key, value]) => {
+        if (value === undefined || value === null)
+            return [];
+        const name = prefix ? `${prefix}[${key}]` : key;
+        if (Array.isArray(value)) {
+            return value.flatMap((item, i) => typeof item === "object"
+                ? encode(item, `${name}[${i}]`)
+                : [[`${name}[${i}]`, String(item)]]);
+        }
+        return typeof value === "object"
+            ? encode(value, name)
+            : [[name, String(value)]];
+    });
+}
+export async function stripeCall(options, method, path, params = {}) {
+    const pairs = encode(params);
+    const body = new URLSearchParams(pairs).toString();
+    const url = method === "GET" && body ? `${BASE}${path}?${body}` : `${BASE}${path}`;
+    const response = await options.fetch(url, {
+        method,
+        headers: {
+            authorization: `Bearer ${options.key}`,
+            "stripe-version": API_VERSION,
+            ...(method === "POST" ? { "content-type": "application/x-www-form-urlencoded" } : {}),
+            ...(options.idempotency ? { "idempotency-key": options.idempotency } : {}),
+        },
+        ...(method === "POST" ? { body } : {}),
+    });
+    const answer = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        throw Object.assign(new Error(answer.error?.message ?? `Stripe answered ${response.status}.`), { code: answer.error?.code ?? "stripe", status: response.status });
+    }
+    return answer;
+}

package/stripe/shared/events.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What Stripe says, as what the app keeps. Whichever account it comes from:
+ * a signature checked, then an event read as a fact for `billing.apply`, which
+ * knows nothing of Stripe. Pure, apart from the clock and the crypto.
+ */
+import type { PaymentFact, PeriodFact, PlanFact } from "../../credits/contract.js";
+/** `Stripe-Signature`, checked against the raw body: from this account, and recent. */
+export declare function verified(secret: string, payload: string, header: string | null, now?: number): Promise<boolean>;
+/** The events acted on: subscribe a webhook to these. */
+export declare const EVENTS: string[];
+/** What an event comes to for an org: facts for `billing.apply`; nothing when it isn't ours. */
+export type Fact = {
+    org: string;
+    plan?: PlanFact;
+    payment?: PaymentFact;
+    period?: PeriodFact;
+};
+type Any = Record<string, any>;
+export declare function factOf(event: {
+    id: string;
+    type: string;
+    created?: number;
+    livemode?: boolean;
+    data: {
+        object: Any;
+        previous_attributes?: Any;
+    };
+}, seller: {
+    name: string;
+    rate?: number;
+}, 
+/** The plan an org goes back to when its subscription ends. */
+start: string): Fact | null;
+/**
+ * A dispute's credits, once its charge is known: opened, they go, as it holds the
+ * money until it's decided; won, they come back.
+ */
+export declare function factOfDispute(type: string, dispute: Any, charge: Any, seller: {
+    name: string;
+    rate?: number;
+}): Fact | null;
+export {};