@tollwyn/baukasten 0.0.2 → 1.2.2

package/dist/server/baukasten-migrations.js

@@ -0,0 +1,126 @@
+// The layer of the baukasten: its migrations, in the schema `baukasten`, as text in the code, so that
+// they travel with it however a product bundles the package. Each is forward-only and never changes
+// once released (baukasten-migrations.test.ts); the migration command lays `baukasten.migrations`,
+// the list of these, before the first.
+export const BAUKASTEN_MIGRATIONS = [
+    {
+        // The list of the migrations of the product: in the schema of the baukasten, so that the schema
+        // public belongs to the product alone.
+        name: '001_product_migrations.sql',
+        sql: `CREATE TABLE baukasten.product_migrations (
+	name text PRIMARY KEY,
+	checksum text NOT NULL,
+	applied_at timestamptz NOT NULL DEFAULT now()
+);
+`
+    },
+    {
+        // Secrets are kept as SHA-256, passwords as scrypt. A deleted account keeps its row without its
+        // address, for the numbers and the books; a product refers to an account by its id alone.
+        name: '002_accounts.sql',
+        sql: `CREATE TABLE baukasten.accounts (
+	id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+	email text UNIQUE CHECK (email = lower(email)),
+	password_hash text,
+	email_verified_at timestamptz,
+	-- The terms accepted at sign-up, named by their day, and when; accepting them includes the
+	-- statement to act for a business, which sign-up asks as well.
+	terms_version text NOT NULL,
+	terms_accepted_at timestamptz NOT NULL,
+	created_at timestamptz NOT NULL DEFAULT now(),
+	deleted_at timestamptz,
+	CHECK ((deleted_at IS NULL) = (email IS NOT NULL)),
+	CHECK (deleted_at IS NULL OR (password_hash IS NULL AND email_verified_at IS NULL))
+);
+
+CREATE TABLE baukasten.sessions (
+	token_hash bytea PRIMARY KEY,
+	account_id uuid NOT NULL REFERENCES baukasten.accounts (id),
+	created_at timestamptz NOT NULL DEFAULT now(),
+	expires_at timestamptz NOT NULL
+);
+CREATE INDEX sessions_account ON baukasten.sessions (account_id);
+
+-- One-time links sent by mail: confirm the address, set a new password, change the address.
+CREATE TABLE baukasten.links (
+	token_hash bytea PRIMARY KEY,
+	account_id uuid NOT NULL REFERENCES baukasten.accounts (id),
+	purpose text NOT NULL CHECK (purpose IN ('verify', 'reset', 'change_email')),
+	new_email text CHECK (new_email = lower(new_email)),
+	created_at timestamptz NOT NULL DEFAULT now(),
+	expires_at timestamptz NOT NULL,
+	used_at timestamptz,
+	CHECK ((purpose = 'change_email') = (new_email IS NOT NULL))
+);
+CREATE INDEX links_account ON baukasten.links (account_id);
+
+CREATE TABLE baukasten.api_keys (
+	id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+	account_id uuid NOT NULL REFERENCES baukasten.accounts (id),
+	name text NOT NULL CHECK (length(name) BETWEEN 1 AND 80),
+	key_hash bytea NOT NULL UNIQUE,
+	-- The start of the key, to tell keys apart in a list; far too short to use.
+	prefix text NOT NULL,
+	created_at timestamptz NOT NULL DEFAULT now(),
+	revoked_at timestamptz
+);
+CREATE INDEX api_keys_account ON baukasten.api_keys (account_id);
+`
+    },
+    {
+        // Every new column has a default, so that the version before signs up accounts as it did.
+        name: '003_stripe_and_sales.sql',
+        sql: `-- The Kennung of the link an account came by (ohne without one); the mode of Stripe it was made
+-- in, live once it gets a customer with the live key; and its customer at Stripe.
+ALTER TABLE baukasten.accounts
+	ADD COLUMN via text NOT NULL DEFAULT 'ohne'
+		CHECK (length(via) <= 32 AND via ~ '^[a-z0-9]+(-[a-z0-9]+)*$'),
+	ADD COLUMN stripe_mode text NOT NULL DEFAULT 'test' CHECK (stripe_mode IN ('test', 'live')),
+	ADD COLUMN stripe_customer_id text UNIQUE;
+
+-- Every event of the webhook that was applied, so that each applies once.
+CREATE TABLE baukasten.stripe_events (
+	id text PRIMARY KEY,
+	type text NOT NULL,
+	received_at timestamptz NOT NULL DEFAULT now()
+);
+
+-- The subscriptions of the accounts as Stripe last said: each read back under the lock of its
+-- account. The lookup key is gone once a newer price took it; the subscription keeps its price.
+CREATE TABLE baukasten.subscriptions (
+	id text PRIMARY KEY,
+	account_id uuid NOT NULL REFERENCES baukasten.accounts (id),
+	status text NOT NULL,
+	product text NOT NULL,
+	price text NOT NULL,
+	lookup_key text,
+	quantity integer NOT NULL CHECK (quantity >= 0),
+	updated_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX subscriptions_account ON baukasten.subscriptions (account_id);
+
+-- The revenue: paid invoices of the subscriptions and paid purchases (a purchase makes no invoice),
+-- in the smallest unit of their currency, as Stripe writes it.
+CREATE TABLE baukasten.invoices (
+	id text PRIMARY KEY,
+	account_id uuid NOT NULL REFERENCES baukasten.accounts (id),
+	amount bigint NOT NULL CHECK (amount >= 0),
+	currency text NOT NULL CHECK (currency ~ '^[a-z]{3}$'),
+	paid_at timestamptz NOT NULL
+);
+CREATE INDEX invoices_account ON baukasten.invoices (account_id);
+
+-- A purchase is named by its Checkout session, with the product and the lookup key of its price.
+CREATE TABLE baukasten.purchases (
+	id text PRIMARY KEY,
+	account_id uuid NOT NULL REFERENCES baukasten.accounts (id),
+	product text NOT NULL,
+	price text NOT NULL,
+	amount bigint NOT NULL CHECK (amount >= 0),
+	currency text NOT NULL CHECK (currency ~ '^[a-z]{3}$'),
+	paid_at timestamptz NOT NULL
+);
+CREATE INDEX purchases_account ON baukasten.purchases (account_id);
+`
+    }
+];

package/dist/server/billing.d.ts

@@ -0,0 +1,94 @@
+import type { Catalog } from '../product.js';
+import type { Account } from './accounts.js';
+import { type Shop } from './catalog.js';
+import type { StripeMode } from './config.js';
+import type { Log } from './log.js';
+import type { Db, Queryable, StripeApi, SubscriptionStatus } from './ports.js';
+/** A failure Stripe reported, named by its kind, like `authentication_error`; never with the key. */
+export declare class StripeFailed extends Error {
+    name: string;
+    readonly kind: string;
+    constructor(kind: string, message: string, options?: ErrorOptions);
+}
+/** A subscription as the product gets it: its product and the lookup key of its price. */
+export interface Subscription {
+    id: string;
+    status: SubscriptionStatus;
+    product: string;
+    /** Null when the price gave its lookup key to a newer one; the subscription keeps its price. */
+    price: string | null;
+    quantity: number;
+}
+/** The subscription of an account as Stripe has it now. */
+export interface SubscriptionChange {
+    accountId: string;
+    subscription: Subscription;
+}
+/** A purchase of a price of the catalog, paid; its id is that of its Checkout. */
+export interface Purchase {
+    id: string;
+    accountId: string;
+    product: string;
+    price: string;
+    /** In the smallest unit of the currency. */
+    amount: number;
+    /** Like CHF. */
+    currency: string;
+    paidAt: Date;
+}
+/** What the baukasten calls in the product when Stripe reports a change, in the same transaction. */
+export interface BillingHooks {
+    subscriptionChanged(tx: Queryable, change: SubscriptionChange): Promise<void>;
+    purchasePaid(tx: Queryable, purchase: Purchase): Promise<void>;
+}
+/** A price of the catalog by its lookup key, with a quantity where the product counts one. */
+export interface Order {
+    price: string;
+    /** For a subscription whose product counts a quantity; 1 without. */
+    quantity?: number;
+    /** Paths of the product: back from Checkout after paying, and after leaving it. */
+    success: string;
+    cancel: string;
+}
+/** A Checkout page, or none, because the account already has a running subscription. */
+export type CheckoutPage = {
+    kind: 'open';
+    url: string;
+} | {
+    kind: 'subscribed';
+};
+export type Received = {
+    kind: 'invalid';
+} | {
+    kind: 'applied';
+    type: string;
+} | {
+    kind: 'repeated';
+    type: string;
+};
+export interface Billing {
+    checkout(account: Account, order: Order): Promise<CheckoutPage>;
+    /** The customer portal of the account, which leads back to the path `back`. */
+    portal(account: Account, back: string): Promise<string>;
+    hasCustomer(accountId: string): Promise<boolean>;
+    /** Verifies one request of the webhook and applies its event once. */
+    receive(payload: string, signature: string | null): Promise<Received>;
+    /** Ends every subscription of the account at once, as when it is deleted. */
+    endSubscriptions(accountId: string): Promise<void>;
+    /** Receipts and invoices follow a new login address. */
+    followEmail(accountId: string, email: string): Promise<void>;
+}
+/** Billing without Stripe, locally: an account that is no customer has nothing to end or follow. */
+export declare function noBilling(db: Queryable): Billing;
+export declare function createBilling(options: {
+    db: Db;
+    stripe: StripeApi;
+    catalog: Catalog;
+    shop: Shop;
+    mode: StripeMode;
+    hooks: BillingHooks;
+    log: Log;
+    now: () => Date;
+    /** The sentence by the box for the terms in Checkout, in Markdown, with their link. */
+    termsMessage: (termsUrl: string) => string;
+}): Billing;

package/dist/server/billing.js

@@ -0,0 +1,349 @@
+import { NO_DEFAULT_PORTAL, priceFits, pricesOf } from './catalog.js';
+/** A failure Stripe reported, named by its kind, like `authentication_error`; never with the key. */
+export class StripeFailed extends Error {
+    name = 'StripeFailed';
+    kind;
+    constructor(kind, message, options) {
+        super(message, options);
+        this.kind = kind;
+    }
+}
+const ENDED = ['canceled', 'incomplete_expired'];
+const running = (status) => !ENDED.includes(status);
+/** Stripe keeps a Checkout open for at least this long; one from another tab expires soon after. */
+const CHECKOUT_OPEN_MS = 31 * 60_000;
+const OWN_PATH = /^\/(?!\/)[^\s\\]*$/;
+function ownPath(path, what) {
+    if (!OWN_PATH.test(path))
+        throw new Error(`${what} must be a path of the product: ${path}`);
+    return path;
+}
+const NOT_CONFIGURED = 'Stripe is not configured: STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET are missing';
+/** The customer of the account at Stripe and the mode of the account, which is that of the customer. */
+async function customerOf(db, accountId) {
+    const [row] = await db.query('SELECT stripe_customer_id, stripe_mode FROM baukasten.accounts WHERE id = $1', [accountId]);
+    if (row === undefined)
+        throw new Error('no such account');
+    return { id: row.stripe_customer_id, mode: row.stripe_mode };
+}
+/** Billing without Stripe, locally: an account that is no customer has nothing to end or follow. */
+export function noBilling(db) {
+    const without = async (accountId) => {
+        if ((await customerOf(db, accountId)).id !== null) {
+            throw new Error(`the account is a customer at Stripe, but ${NOT_CONFIGURED}`);
+        }
+    };
+    return {
+        checkout: () => Promise.reject(new Error(NOT_CONFIGURED)),
+        portal: () => Promise.reject(new Error(NOT_CONFIGURED)),
+        hasCustomer: async (accountId) => (await customerOf(db, accountId)).id !== null,
+        receive: () => Promise.reject(new Error(NOT_CONFIGURED)),
+        endSubscriptions: without,
+        followEmail: without
+    };
+}
+export function createBilling(options) {
+    const { db, stripe, catalog, shop, mode, hooks, log, now } = options;
+    const currency = catalog.currency.toLowerCase();
+    const prices = new Map(pricesOf(catalog).map((price) => [price.lookupKey, price]));
+    const products = new Map(catalog.products.map((product) => [product.id, product]));
+    const priceIds = new Map();
+    let portalId = null;
+    /** The price at Stripe for the catalog's, found by its lookup key once per process. */
+    async function priceId(wanted) {
+        const known = priceIds.get(wanted.lookupKey);
+        if (known !== undefined)
+            return known;
+        const found = await stripe.activePrice(wanted.lookupKey);
+        // The pages promise the price of the catalog; a different one at Stripe would charge another.
+        if (found === null || !priceFits(found, wanted)) {
+            throw new Error(`the price ${wanted.lookupKey} at Stripe is not the one of the catalog: migrate first`);
+        }
+        priceIds.set(wanted.lookupKey, found.id);
+        return found.id;
+    }
+    async function portalConfiguration() {
+        if (portalId !== null)
+            return portalId;
+        const portal = await stripe.defaultPortal();
+        if (portal === null)
+            throw new Error(NO_DEFAULT_PORTAL);
+        portalId = portal.id;
+        return portalId;
+    }
+    /**
+     * The customer of the account, made at the first need. A request at the same time may have made
+     * one first: the stored one wins. An account that gets its customer with the live key is live from
+     * then on; one from the test mode has customers of the test mode only.
+     */
+    async function customer(account) {
+        // A customer of the other mode is out of reach of this key: Stripe says so loudly.
+        const known = (await customerOf(db, account.id)).id;
+        if (known !== null)
+            return known;
+        const created = await stripe.createCustomer({ email: account.email, accountId: account.id });
+        const [row] = await db.query(`UPDATE baukasten.accounts SET
+				stripe_mode = CASE WHEN stripe_customer_id IS NULL AND $3 THEN 'live' ELSE stripe_mode END,
+				stripe_customer_id = coalesce(stripe_customer_id, $2)
+			 WHERE id = $1 AND deleted_at IS NULL
+			 RETURNING stripe_customer_id`, [account.id, created, mode === 'live']);
+        if (row === undefined)
+            throw new Error('the account was deleted');
+        return row.stripe_customer_id;
+    }
+    function productOf(price) {
+        const product = products.get(price.product);
+        if (product === undefined)
+            throw new Error(`a price without its product: ${price.lookupKey}`);
+        return product;
+    }
+    /**
+     * The customer of the account, unless it is one of the test mode under the live key: that one the
+     * key does not reach, and its subscriptions move no money. A live customer under the test key, as
+     * after a switch to live taken back, is asked for and fails loudly: its subscriptions move money.
+     */
+    async function reachable(accountId) {
+        const customer = await customerOf(db, accountId);
+        if (customer.id === null)
+            return { kind: 'none' };
+        if (customer.mode === 'test' && mode === 'live')
+            return { kind: 'test mode' };
+        return { kind: 'customer', id: customer.id };
+    }
+    /** The customer to act on at Stripe; one of the test mode under the live key is left alone. */
+    async function actOn(accountId) {
+        const customer = await reachable(accountId);
+        switch (customer.kind) {
+            case 'customer':
+                return customer.id;
+            case 'none':
+                return null;
+            case 'test mode':
+                log.info('stripe: a customer of the test mode, left alone', { account: accountId });
+                return null;
+        }
+    }
+    /** The account of a customer, locked until the transaction ends; none for another's customer. */
+    async function accountOf(tx, customerId, event) {
+        const [account] = await tx.query(`SELECT id, deleted_at IS NOT NULL AS deleted FROM baukasten.accounts
+			 WHERE stripe_customer_id = $1 FOR UPDATE`, [customerId]);
+        if (account !== undefined)
+            return account;
+        log.warn('stripe: an event of a customer without an account', {
+            type: event.type,
+            event: event.id,
+            customer: customerId
+        });
+        return null;
+    }
+    async function syncSubscription(tx, event, customerId, subscriptionId) {
+        const account = await accountOf(tx, customerId, event);
+        if (account === null)
+            return;
+        const read = await stripe.subscription(subscriptionId);
+        // A Checkout opened before the deletion and paid after it: a deleted account pays for nothing.
+        // Its end comes back as an event of its own and stays.
+        if (account.deleted && running(read.status)) {
+            await stripe.cancelSubscription(read.id);
+            log.warn('stripe: a running subscription of a deleted account, ended; the operator refunds its paid invoice', { account: account.id, subscription: read.id, invoice: read.latestInvoice });
+            return;
+        }
+        await tx.query(`INSERT INTO baukasten.subscriptions (id, account_id, status, product, price, lookup_key, quantity)
+			 VALUES ($1, $2, $3, $4, $5, $6, $7)
+			 ON CONFLICT (id) DO UPDATE SET status = excluded.status, product = excluded.product,
+				price = excluded.price, lookup_key = excluded.lookup_key, quantity = excluded.quantity,
+				updated_at = now()`, [
+            read.id,
+            account.id,
+            read.status,
+            read.product,
+            read.price.id,
+            read.price.lookupKey,
+            read.quantity
+        ]);
+        // The product deleted its data of a deleted account; there is nothing left to entitle.
+        if (account.deleted)
+            return;
+        await hooks.subscriptionChanged(tx, {
+            accountId: account.id,
+            subscription: {
+                id: read.id,
+                status: read.status,
+                product: read.product,
+                price: read.price.lookupKey,
+                quantity: read.quantity
+            }
+        });
+    }
+    function otherCurrency(event, paid) {
+        if (paid === currency)
+            return;
+        log.warn('stripe: paid in another currency than that of the catalog, not counted', {
+            type: event.type,
+            event: event.id,
+            currency: paid
+        });
+    }
+    async function purchasePaid(tx, event, session) {
+        if (!session.paid)
+            return;
+        const account = await accountOf(tx, session.customerId, event);
+        if (account === null)
+            return;
+        otherCurrency(event, session.currency);
+        const inserted = await tx.query(`INSERT INTO baukasten.purchases (id, account_id, product, price, amount, currency, paid_at)
+			 VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (id) DO NOTHING RETURNING id`, [
+            session.id,
+            account.id,
+            session.product,
+            session.lookupKey,
+            session.amount,
+            session.currency,
+            event.created
+        ]);
+        // Completed and paid later (a payment that takes days) are two events of one purchase.
+        if (inserted.length === 0 || account.deleted)
+            return;
+        await hooks.purchasePaid(tx, {
+            id: session.id,
+            accountId: account.id,
+            product: session.product,
+            price: session.lookupKey,
+            amount: session.amount,
+            currency: session.currency.toUpperCase(),
+            paidAt: event.created
+        });
+    }
+    async function checkoutCompleted(tx, event, session) {
+        switch (session.mode) {
+            case 'subscription':
+                return syncSubscription(tx, event, session.customerId, session.subscriptionId);
+            case 'payment':
+                return purchasePaid(tx, event, session);
+            case 'other':
+                log.info('stripe: a Checkout the baukasten did not open, left alone', {
+                    event: event.id,
+                    session: session.id
+                });
+                return;
+        }
+    }
+    async function apply(tx, event) {
+        switch (event.kind) {
+            case 'checkout':
+                return checkoutCompleted(tx, event, event.session);
+            case 'subscription':
+                return syncSubscription(tx, event, event.customerId, event.subscriptionId);
+            case 'invoice': {
+                const { invoice } = event;
+                const account = await accountOf(tx, invoice.customerId, event);
+                if (account === null)
+                    return;
+                otherCurrency(event, invoice.currency);
+                await tx.query(`INSERT INTO baukasten.invoices (id, account_id, amount, currency, paid_at)
+					 VALUES ($1, $2, $3, $4, $5) ON CONFLICT (id) DO NOTHING`, [invoice.id, account.id, invoice.amount, invoice.currency, invoice.paidAt]);
+                return;
+            }
+            case 'other':
+                return;
+        }
+    }
+    return {
+        async checkout(account, order) {
+            const wanted = prices.get(order.price);
+            if (wanted === undefined)
+                throw new Error(`the catalog has no price ${order.price}`);
+            const product = productOf(wanted);
+            const base = {
+                accountId: account.id,
+                successUrl: `${shop.origin}${ownPath(order.success, 'success')}`,
+                cancelUrl: `${shop.origin}${ownPath(order.cancel, 'cancel')}`,
+                termsMessage: options.termsMessage(`${shop.origin}/terms`),
+                expiresAt: new Date(now().getTime() + CHECKOUT_OPEN_MS)
+            };
+            switch (product.kind) {
+                case 'subscription': {
+                    const max = product.quantity === undefined ? 1 : product.quantity.max;
+                    const quantity = order.quantity ?? 1;
+                    if (!Number.isInteger(quantity) || quantity < 1 || quantity > max) {
+                        throw new Error(`the quantity of ${order.price} is 1 to ${max}, not ${quantity}`);
+                    }
+                    const stripePrice = await priceId(wanted);
+                    const customerId = await customer(account);
+                    // A repeated click finds the running subscription. Two Checkouts open at the same time
+                    // can still make two subscriptions; that each expires soon only narrows the window.
+                    const open = (await stripe.subscriptionsOf(customerId)).filter((s) => running(s.status));
+                    if (open.length > 0)
+                        return { kind: 'subscribed' };
+                    const url = await stripe.createCheckout({
+                        ...base,
+                        customerId,
+                        priceId: stripePrice,
+                        mode: 'subscription',
+                        quantity,
+                        adjustable: product.quantity === undefined
+                            ? { kind: 'fixed' }
+                            : { kind: 'up to', max: product.quantity.max }
+                    });
+                    return { kind: 'open', url };
+                }
+                case 'purchase': {
+                    if (order.quantity !== undefined && order.quantity !== 1) {
+                        throw new Error(`a purchase of ${order.price} is one, not ${order.quantity}`);
+                    }
+                    const stripePrice = await priceId(wanted);
+                    const url = await stripe.createCheckout({
+                        ...base,
+                        customerId: await customer(account),
+                        priceId: stripePrice,
+                        mode: 'payment',
+                        product: product.id,
+                        lookupKey: wanted.lookupKey
+                    });
+                    return { kind: 'open', url };
+                }
+            }
+        },
+        async portal(account, back) {
+            const configurationId = await portalConfiguration();
+            return stripe.createPortalSession({
+                customerId: await customer(account),
+                configurationId,
+                returnUrl: `${shop.origin}${ownPath(back, 'back')}`
+            });
+        },
+        hasCustomer: async (accountId) => (await reachable(accountId)).kind === 'customer',
+        async receive(payload, signature) {
+            const read = stripe.event(payload, signature);
+            if (read.kind === 'invalid')
+                return { kind: 'invalid' };
+            const { event } = read;
+            const applied = await db.transaction(async (tx) => {
+                const fresh = await tx.query(`INSERT INTO baukasten.stripe_events (id, type) VALUES ($1, $2)
+					 ON CONFLICT (id) DO NOTHING RETURNING id`, [event.id, event.type]);
+                if (fresh.length === 0)
+                    return false;
+                await apply(tx, event);
+                return true;
+            });
+            log.info('stripe event', { type: event.type, event: event.id, applied });
+            return applied
+                ? { kind: 'applied', type: event.type }
+                : { kind: 'repeated', type: event.type };
+        },
+        async endSubscriptions(accountId) {
+            const customerId = await actOn(accountId);
+            if (customerId === null)
+                return;
+            for (const subscription of await stripe.subscriptionsOf(customerId)) {
+                if (running(subscription.status))
+                    await stripe.cancelSubscription(subscription.id);
+            }
+        },
+        async followEmail(accountId, email) {
+            const customerId = await actOn(accountId);
+            if (customerId !== null)
+                await stripe.updateCustomerEmail(customerId, email);
+        }
+    };
+}

package/dist/server/catalog.d.ts

@@ -0,0 +1,39 @@
+import type { Catalog } from '../product.js';
+import type { NewPrice, PortalConfiguration, StripeApi, StripePrice } from './ports.js';
+/** The name and the address of the product, which the customer portal shows. */
+export interface Shop {
+    name: string;
+    origin: string;
+}
+export interface CatalogStep {
+    subject: 'product' | 'price' | 'portal';
+    id: string;
+    action: 'created' | 'updated' | 'exists';
+}
+export declare function pricesOf(catalog: Catalog): NewPrice[];
+/** Whether the price at Stripe charges what the catalog says. */
+export declare function priceFits(found: StripePrice, wanted: NewPrice): boolean;
+/**
+ * The default configuration of the customer portal names the product and links its own pages: an
+ * account copied from another one brings that one's along.
+ */
+export declare function portalConfiguration(catalog: Catalog, shop: Shop, priceId: (lookupKey: string) => string): PortalConfiguration;
+/**
+ * Whether `found` holds every value of `wanted`. Lists hold the same items in any order: Stripe
+ * need not keep the order it was given.
+ */
+export declare function contains(found: unknown, wanted: unknown): boolean;
+/** Only the Dashboard creates the default configuration of the customer portal. */
+export declare const NO_DEFAULT_PORTAL = "the Stripe account has no default configuration of the customer portal in this mode: save the settings of the customer portal once in the Stripe Dashboard, then migrate again";
+export declare function setUpCatalog(stripe: StripeApi, catalog: Catalog, shop: Shop): Promise<CatalogStep[]>;
+/** What the migration would change at Stripe, as `product <id>`, `price <key>` or `portal`. */
+export declare function catalogDifferences(stripe: StripeApi, catalog: Catalog, shop: Shop): Promise<string[]>;
+/**
+ * The enabled webhook endpoints of the Stripe account that are not this product's: an account copied
+ * from another product brings that one's along, and they would get the events of this one. Named by
+ * id and host: the path of an endpoint often carries a secret.
+ */
+export declare function foreignWebhooks(stripe: StripeApi, origin: string): Promise<{
+    id: string;
+    host: string;
+}[]>;