@tollwyn/baukasten 0.0.2 → 1.2.3

package/dist/server/catalog.js

@@ -0,0 +1,193 @@
+import { WEBHOOK_PATH } from './stripe.js';
+export function pricesOf(catalog) {
+    const currency = catalog.currency.toLowerCase();
+    return catalog.products.flatMap((product) => {
+        switch (product.kind) {
+            case 'subscription':
+                return product.prices.map((price) => ({
+                    product: product.id,
+                    lookupKey: price.lookupKey,
+                    amount: price.amount,
+                    currency,
+                    type: 'recurring',
+                    interval: price.interval
+                }));
+            case 'purchase':
+                return product.prices.map((price) => ({
+                    product: product.id,
+                    lookupKey: price.lookupKey,
+                    amount: price.amount,
+                    currency,
+                    type: 'one_time'
+                }));
+        }
+    });
+}
+/** Whether the price at Stripe charges what the catalog says. */
+export function priceFits(found, wanted) {
+    if (found.product !== wanted.product ||
+        found.amount !== wanted.amount ||
+        found.currency !== wanted.currency) {
+        return false;
+    }
+    switch (wanted.type) {
+        case 'one_time':
+            return found.type === 'one_time';
+        case 'recurring':
+            return (found.type === 'recurring' &&
+                found.interval === wanted.interval &&
+                found.intervalCount === 1);
+    }
+}
+/**
+ * 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 function portalConfiguration(catalog, shop, priceId) {
+    const subscriptions = catalog.products.flatMap((product) => product.kind === 'subscription' ? [product] : []);
+    const prices = subscriptions.reduce((count, product) => count + product.prices.length, 0);
+    const allowed = [
+        ...(prices > 1 ? ['price'] : []),
+        ...(subscriptions.some((product) => product.quantity !== undefined)
+            ? ['quantity']
+            : [])
+    ];
+    return {
+        business_profile: {
+            headline: shop.name,
+            privacy_policy_url: `${shop.origin}/privacy`,
+            terms_of_service_url: `${shop.origin}/terms`
+        },
+        default_return_url: `${shop.origin}/account`,
+        features: {
+            customer_update: { enabled: true, allowed_updates: ['address', 'name', 'tax_id'] },
+            invoice_history: { enabled: true },
+            payment_method_update: { enabled: true },
+            subscription_cancel: { enabled: true, mode: 'at_period_end', proration_behavior: 'none' },
+            subscription_update: allowed.length === 0
+                ? { enabled: false }
+                : {
+                    enabled: true,
+                    default_allowed_updates: allowed,
+                    proration_behavior: 'create_prorations',
+                    products: subscriptions.map((product) => ({
+                        product: product.id,
+                        prices: product.prices.map((price) => priceId(price.lookupKey)),
+                        adjustable_quantity: product.quantity === undefined
+                            ? { enabled: false }
+                            : { enabled: true, minimum: 1, maximum: product.quantity.max }
+                    }))
+                }
+        }
+    };
+}
+/**
+ * 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 function contains(found, wanted) {
+    if (Array.isArray(wanted)) {
+        if (!Array.isArray(found) || found.length !== wanted.length)
+            return false;
+        const taken = new Set();
+        return wanted.every((item) => {
+            const at = found.findIndex((candidate, index) => !taken.has(index) && contains(candidate, item));
+            taken.add(at);
+            return at >= 0;
+        });
+    }
+    if (typeof wanted === 'object' && wanted !== null) {
+        if (typeof found !== 'object' || found === null || Array.isArray(found))
+            return false;
+        return Object.entries(wanted).every(([key, value]) => contains(Reflect.get(found, key), value));
+    }
+    return found === wanted;
+}
+/** Only the Dashboard creates the default configuration of the customer portal. */
+export 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 async function setUpCatalog(stripe, catalog, shop) {
+    const steps = [];
+    for (const product of catalog.products) {
+        const found = await stripe.product(product.id);
+        const wanted = { id: product.id, name: product.name };
+        if (found === null) {
+            await stripe.createProduct(wanted);
+            steps.push({ subject: 'product', id: product.id, action: 'created' });
+        }
+        else if (!found.active || found.name !== product.name) {
+            await stripe.updateProduct(wanted);
+            steps.push({ subject: 'product', id: product.id, action: 'updated' });
+        }
+        else {
+            steps.push({ subject: 'product', id: product.id, action: 'exists' });
+        }
+    }
+    const ids = new Map();
+    for (const wanted of pricesOf(catalog)) {
+        const found = await stripe.activePrice(wanted.lookupKey);
+        if (found !== null && priceFits(found, wanted)) {
+            ids.set(wanted.lookupKey, found.id);
+            steps.push({ subject: 'price', id: wanted.lookupKey, action: 'exists' });
+        }
+        else {
+            ids.set(wanted.lookupKey, await stripe.createPrice(wanted));
+            steps.push({
+                subject: 'price',
+                id: wanted.lookupKey,
+                action: found === null ? 'created' : 'updated'
+            });
+        }
+    }
+    const portal = await stripe.defaultPortal();
+    if (portal === null)
+        throw new Error(NO_DEFAULT_PORTAL);
+    const wanted = portalConfiguration(catalog, shop, (key) => {
+        const id = ids.get(key);
+        if (id === undefined)
+            throw new Error(`the price ${key} was not set up`);
+        return id;
+    });
+    if (contains(portal.configuration, wanted)) {
+        steps.push({ subject: 'portal', id: portal.id, action: 'exists' });
+    }
+    else {
+        await stripe.updatePortal(portal.id, wanted);
+        steps.push({ subject: 'portal', id: portal.id, action: 'updated' });
+    }
+    return steps;
+}
+/** What the migration would change at Stripe, as `product <id>`, `price <key>` or `portal`. */
+export async function catalogDifferences(stripe, catalog, shop) {
+    const [products, prices, portal] = await Promise.all([
+        Promise.all(catalog.products.map(async (product) => [product, await stripe.product(product.id)])),
+        Promise.all(pricesOf(catalog).map(async (price) => [price, await stripe.activePrice(price.lookupKey)])),
+        stripe.defaultPortal()
+    ]);
+    const differences = [
+        ...products.flatMap(([product, found]) => found !== null && found.active && found.name === product.name ? [] : [`product ${product.id}`]),
+        ...prices.flatMap(([wanted, found]) => found !== null && priceFits(found, wanted) ? [] : [`price ${wanted.lookupKey}`])
+    ];
+    // With a price missing, the portal would point at a price the migration has yet to create.
+    if (differences.some((difference) => difference.startsWith('price ')))
+        return differences;
+    const ids = new Map(prices.flatMap(([wanted, found]) => found === null ? [] : [[wanted.lookupKey, found.id]]));
+    const fits = portal !== null &&
+        contains(portal.configuration, portalConfiguration(catalog, shop, (key) => {
+            const id = ids.get(key);
+            if (id === undefined)
+                throw new Error(`the price ${key} is not at Stripe`);
+            return id;
+        }));
+    return fits ? differences : [...differences, 'portal'];
+}
+/**
+ * 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 async function foreignWebhooks(stripe, origin) {
+    const own = `${origin}${WEBHOOK_PATH}`;
+    return (await stripe.webhookEndpoints())
+        .filter((endpoint) => endpoint.enabled && endpoint.url !== own)
+        .map(({ id, url }) => ({ id, host: URL.canParse(url) ? new URL(url).host : 'no address' }));
+}

package/dist/server/config.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import type { Language, Product, ProductEnv } from '../product.js';
+import { BAUKASTEN_VARIABLES, STANDARD_VARIABLES, type StandardVariable } from '../variables.js';
+export { BAUKASTEN_VARIABLES, STANDARD_VARIABLES };
+export type Env = Readonly<Record<string, string | undefined>>;
+export declare class ConfigError extends Error {
+    readonly problems: readonly string[];
+    constructor(problems: readonly string[]);
+}
+/** The relay of the fleet, plain SMTP without a login; locally without it every mail goes to the log. */
+export type Mail = {
+    kind: 'smtp';
+    host: string;
+    port: number;
+    from: string;
+} | {
+    kind: 'log';
+};
+/** The mode of Stripe, by the prefix of the key: test until the delivery service switches to live. */
+export type StripeMode = 'test' | 'live';
+export type Stripe = {
+    kind: 'stripe';
+    secretKey: string;
+    webhookSecret: string;
+    mode: StripeMode;
+    /** Stripe itself, or in the tests of a product its double on this machine. */
+    api: {
+        kind: 'stripe';
+    } | {
+        kind: 'double';
+        url: string;
+    };
+} | {
+    kind: 'none';
+};
+/** The commercial register: no entry, or the company identification number (UID) of the entry. */
+export type Register = {
+    kind: 'none';
+} | {
+    kind: 'entered';
+    uid: string;
+};
+/** Who runs the product, for its legal pages. */
+export interface Operator {
+    name: string;
+    address: string;
+    register: Register;
+    /**
+     * Not registered for VAT: with a VAT number the product does not start, since it would have to
+     * charge VAT through Stripe Tax, which the baukasten does not support yet.
+     */
+    vat: 'none';
+    /** The place of jurisdiction of the terms, in Switzerland. */
+    jurisdiction: string;
+}
+export interface Config<E extends ProductEnv = ProductEnv> {
+    mode: 'production' | 'local';
+    language: Language;
+    /** Every address of the product starts with it. */
+    publicOrigin: string;
+    port: number;
+    databaseUrl: string;
+    /** The name of the product everywhere: MAIL_FROM_NAME. */
+    name: string;
+    mail: Mail;
+    stripe: Stripe;
+    operator: Operator;
+    /** The bearer token of GET /vertrieb/zahlen. */
+    salesToken: string;
+    /** What runs without locally; empty in production. */
+    missing: readonly StandardVariable[];
+    product: z.output<z.ZodObject<E>>;
+}
+/** The schema of each standard variable of a web app; a Shopify app takes those it shares. */
+export declare const SHAPE: {
+    PUBLIC_ORIGIN: z.ZodPipe<z.ZodURL, z.ZodTransform<string, string>>;
+    PORT: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    DATABASE_URL: z.ZodURL;
+    SMTP_HOST: z.ZodString;
+    SMTP_PORT: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+    MAIL_FROM: z.ZodEmail;
+    MAIL_FROM_NAME: z.ZodString;
+    OPERATOR_NAME: z.ZodString;
+    OPERATOR_ADDRESS: z.ZodString;
+    OPERATOR_REGISTER: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodString]>;
+    OPERATOR_VAT: z.ZodLiteral<"none">;
+    OPERATOR_JURISDICTION: z.ZodString;
+    HOSTING_LOCATION: z.ZodString;
+    STRIPE_SECRET_KEY: z.ZodString;
+    STRIPE_WEBHOOK_SECRET: z.ZodString;
+    VERTRIEB_TOKEN: z.ZodString;
+};
+/** What a value must be; the problem never repeats the value, which may be a secret. */
+export declare const MUST: Record<StandardVariable, string>;
+export declare const DEFAULT_PORT = 3000;
+type Input = Record<string, string | undefined>;
+/** One problem per variable, in the order of `names`: missing, or what its value must be. */
+export declare function problemsOf<N extends string>(issues: readonly z.core.$ZodIssue[], names: readonly N[], input: Input, invalid: (name: N, issue: z.core.$ZodIssue) => string): string[];
+/** A variable that is empty or blank counts as missing. */
+export declare function valueOf(env: Env, name: string): string | undefined;
+/** The port of the server by the rule of loadConfig, which has checked it before the server listens. */
+export declare function portOf(env: Env): number;
+/** The database of the migration command, which needs nothing else. */
+export declare function databaseUrlOf(env: Env): string;
+/** The mode a key of Stripe belongs to; the configuration took only test and live keys. */
+export declare function stripeModeOf(secretKey: string): StripeMode;
+/** Reads the configuration; ConfigError names every problem at once. */
+export declare function loadConfig<E extends ProductEnv>(env: Env, product: Product<E>): Config<E>;

package/dist/server/config.js

@@ -0,0 +1,244 @@
+// In production no variable may be missing. Locally mail and Stripe may be missing (mails go to the
+// log, there is nothing to pay), and `missing` names them.
+import { z } from 'zod';
+import { BAUKASTEN_VARIABLES, STANDARD_VARIABLES } from '../variables.js';
+export { BAUKASTEN_VARIABLES, STANDARD_VARIABLES };
+export class ConfigError extends Error {
+    problems;
+    constructor(problems) {
+        super(`invalid configuration: ${problems.join('; ')}`);
+        this.problems = problems;
+    }
+}
+const tcpPort = z
+    .string()
+    .regex(/^\d{1,5}$/)
+    .transform(Number)
+    .refine((port) => port >= 1 && port <= 65_535);
+const text = z.string();
+const NONE = 'none';
+const UID_WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4];
+/** A company identification number, CHE-123.456.788: its ninth digit checks the others (modulo 11). */
+function isUid(value) {
+    if (!/^CHE-\d{3}\.\d{3}\.\d{3}$/.test(value))
+        return false;
+    const digits = value.replace(/\D/g, '');
+    let sum = 0;
+    for (const [index, weight] of UID_WEIGHTS.entries())
+        sum += weight * Number(digits.charAt(index));
+    const check = (11 - (sum % 11)) % 11;
+    return check !== 10 && check === Number(digits.charAt(8));
+}
+/** The schema of each standard variable of a web app; a Shopify app takes those it shares. */
+export const SHAPE = {
+    PUBLIC_ORIGIN: z.url({ protocol: /^https?$/ }).transform((value) => new URL(value).origin),
+    PORT: tcpPort,
+    DATABASE_URL: z.url({ protocol: /^postgres(?:ql)?$/ }),
+    SMTP_HOST: z.string().regex(/^[A-Za-z0-9.-]+$/),
+    SMTP_PORT: tcpPort,
+    MAIL_FROM: z.email(),
+    MAIL_FROM_NAME: text,
+    OPERATOR_NAME: text,
+    OPERATOR_ADDRESS: text,
+    OPERATOR_REGISTER: z.union([z.literal(NONE), z.string().refine(isUid)]),
+    OPERATOR_VAT: z.literal(NONE),
+    OPERATOR_JURISDICTION: text,
+    // Required like every standard variable, yet unread: the legal pages name the server of the
+    // fleet (legal/fleet.ts).
+    HOSTING_LOCATION: text,
+    STRIPE_SECRET_KEY: z.string().regex(/^(?:sk|rk)_(?:test|live)_[A-Za-z0-9]+$/),
+    STRIPE_WEBHOOK_SECRET: z.string().regex(/^whsec_[A-Za-z0-9]+$/),
+    VERTRIEB_TOKEN: z.string().min(32)
+};
+/**
+ * The Stripe double of the tests, which takes the key and moves no money: only on this machine, so
+ * that no setting sends the key anywhere else.
+ */
+const STRIPE_API_BASE = z
+    .url({ protocol: /^http$/, hostname: /^(?:127\.0\.0\.1|localhost|\[::1\])$/ })
+    .transform((value) => new URL(value).origin);
+/** What a value must be; the problem never repeats the value, which may be a secret. */
+export const MUST = {
+    PUBLIC_ORIGIN: 'an http(s) origin',
+    PORT: 'a TCP port',
+    DATABASE_URL: 'a postgres:// or postgresql:// URL',
+    SMTP_HOST: 'a host name',
+    SMTP_PORT: 'a TCP port',
+    MAIL_FROM: 'an email address',
+    MAIL_FROM_NAME: 'a name',
+    OPERATOR_NAME: 'a name',
+    OPERATOR_ADDRESS: 'an address',
+    OPERATOR_REGISTER: 'none or the company identification number of the entry with its check digit, like CHE-123.456.788',
+    OPERATOR_VAT: 'none: with a VAT number the product would have to charge VAT through Stripe Tax, which this version of the baukasten does not support',
+    OPERATOR_JURISDICTION: 'a place in Switzerland',
+    HOSTING_LOCATION: 'a place',
+    STRIPE_SECRET_KEY: 'a secret or restricted key of Stripe (sk_ or rk_, then test_ or live_)',
+    STRIPE_WEBHOOK_SECRET: 'a signing secret of Stripe (whsec_)',
+    VERTRIEB_TOKEN: 'at least 32 characters'
+};
+export const DEFAULT_PORT = 3000;
+const MAIL = ['SMTP_HOST', 'SMTP_PORT', 'MAIL_FROM'];
+const STRIPE = ['STRIPE_SECRET_KEY', 'STRIPE_WEBHOOK_SECRET'];
+const PRODUCTION = z.object(SHAPE);
+const LOCAL = z.object({
+    ...SHAPE,
+    PORT: SHAPE.PORT.optional(),
+    SMTP_HOST: SHAPE.SMTP_HOST.optional(),
+    SMTP_PORT: SHAPE.SMTP_PORT.optional(),
+    MAIL_FROM: SHAPE.MAIL_FROM.optional(),
+    STRIPE_SECRET_KEY: SHAPE.STRIPE_SECRET_KEY.optional(),
+    STRIPE_WEBHOOK_SECRET: SHAPE.STRIPE_WEBHOOK_SECRET.optional()
+});
+/** One problem per variable, in the order of `names`: missing, or what its value must be. */
+export function problemsOf(issues, names, input, invalid) {
+    const first = new Map();
+    for (const issue of issues) {
+        const name = names.find((n) => n === issue.path[0]);
+        if (name === undefined) {
+            throw new Error(`a configuration issue outside the variables: ${issue.message}`);
+        }
+        if (!first.has(name))
+            first.set(name, issue);
+    }
+    return names.flatMap((name) => {
+        const issue = first.get(name);
+        if (issue === undefined)
+            return [];
+        return [input[name] === undefined ? `${name} is missing` : invalid(name, issue)];
+    });
+}
+function read(schema, input, build) {
+    const result = schema.safeParse(input);
+    if (result.success)
+        return { kind: 'ok', value: build(result.data) };
+    return {
+        kind: 'problems',
+        problems: problemsOf(result.error.issues, STANDARD_VARIABLES, input, (name) => `${name} must be ${MUST[name]}`)
+    };
+}
+function common(data, rest) {
+    return {
+        publicOrigin: data.PUBLIC_ORIGIN,
+        databaseUrl: data.DATABASE_URL,
+        name: data.MAIL_FROM_NAME,
+        operator: {
+            name: data.OPERATOR_NAME,
+            address: data.OPERATOR_ADDRESS,
+            register: data.OPERATOR_REGISTER === NONE
+                ? { kind: 'none' }
+                : { kind: 'entered', uid: data.OPERATOR_REGISTER },
+            vat: data.OPERATOR_VAT,
+            jurisdiction: data.OPERATOR_JURISDICTION
+        },
+        salesToken: data.VERTRIEB_TOKEN,
+        ...rest
+    };
+}
+function production(data) {
+    return common(data, {
+        port: data.PORT,
+        mail: { kind: 'smtp', host: data.SMTP_HOST, port: data.SMTP_PORT, from: data.MAIL_FROM },
+        stripe: {
+            kind: 'stripe',
+            secretKey: data.STRIPE_SECRET_KEY,
+            webhookSecret: data.STRIPE_WEBHOOK_SECRET
+        }
+    });
+}
+function local(data) {
+    const { SMTP_HOST: host, SMTP_PORT: port, MAIL_FROM: from } = data;
+    const { STRIPE_SECRET_KEY: secretKey, STRIPE_WEBHOOK_SECRET: webhookSecret } = data;
+    return common(data, {
+        port: data.PORT ?? DEFAULT_PORT,
+        mail: host !== undefined && port !== undefined && from !== undefined
+            ? { kind: 'smtp', host, port, from }
+            : { kind: 'log' },
+        stripe: secretKey !== undefined && webhookSecret !== undefined
+            ? { kind: 'stripe', secretKey, webhookSecret }
+            : { kind: 'none' }
+    });
+}
+/** "A, B and C" */
+function list(names) {
+    return names.length < 2 ? names.join('') : `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`;
+}
+/** Locally a group is set in full or not at all. */
+function partly(label, names, input) {
+    const absent = names.filter((name) => input[name] === undefined);
+    if (absent.length === 0 || absent.length === names.length)
+        return [];
+    return [
+        `${label} is set only in part: ${list(absent)} ${absent.length === 1 ? 'is' : 'are'} missing`
+    ];
+}
+/** A variable that is empty or blank counts as missing. */
+export function valueOf(env, name) {
+    const raw = env[name]?.trim();
+    return raw === '' ? undefined : raw;
+}
+/** The port of the server by the rule of loadConfig, which has checked it before the server listens. */
+export function portOf(env) {
+    const raw = valueOf(env, 'PORT');
+    if (raw === undefined)
+        return DEFAULT_PORT;
+    const port = SHAPE.PORT.safeParse(raw);
+    if (!port.success)
+        throw new ConfigError([`PORT must be ${MUST.PORT}`]);
+    return port.data;
+}
+/** The database of the migration command, which needs nothing else. */
+export function databaseUrlOf(env) {
+    const raw = valueOf(env, 'DATABASE_URL');
+    if (raw === undefined)
+        throw new ConfigError(['DATABASE_URL is missing']);
+    const url = SHAPE.DATABASE_URL.safeParse(raw);
+    if (!url.success)
+        throw new ConfigError([`DATABASE_URL must be ${MUST.DATABASE_URL}`]);
+    return url.data;
+}
+/** The mode a key of Stripe belongs to; the configuration took only test and live keys. */
+export function stripeModeOf(secretKey) {
+    return /^(?:sk|rk)_live_/.test(secretKey) ? 'live' : 'test';
+}
+/** Reads the configuration; ConfigError names every problem at once. */
+export function loadConfig(env, product) {
+    const value = (name) => valueOf(env, name);
+    const inProduction = env.NODE_ENV === 'production';
+    const input = Object.fromEntries(STANDARD_VARIABLES.map((name) => [name, value(name)]));
+    const names = Object.keys(product.env);
+    const ownInput = Object.fromEntries(names.map((name) => [name, value(name)]));
+    const base = inProduction ? read(PRODUCTION, input, production) : read(LOCAL, input, local);
+    const own = z.object(product.env).safeParse(ownInput);
+    const apiBase = value('STRIPE_API_BASE');
+    const double = apiBase === undefined ? null : STRIPE_API_BASE.safeParse(apiBase);
+    const problems = [
+        ...(base.kind === 'problems' ? base.problems : []),
+        ...(double === null || double.success
+            ? []
+            : ['STRIPE_API_BASE must be an http origin on this machine, for the Stripe double']),
+        ...(own.success
+            ? []
+            : problemsOf(own.error.issues, names, ownInput, (name, issue) => `${name} is invalid: ${issue.message}`)),
+        ...(inProduction ? [] : [...partly('mail', MAIL, input), ...partly('Stripe', STRIPE, input)])
+    ];
+    if (base.kind === 'problems' || !own.success || problems.length > 0) {
+        throw new ConfigError(problems);
+    }
+    const stripe = base.value.stripe;
+    return {
+        mode: inProduction ? 'production' : 'local',
+        language: product.language,
+        ...base.value,
+        stripe: stripe.kind === 'none'
+            ? stripe
+            : {
+                ...stripe,
+                mode: stripeModeOf(stripe.secretKey),
+                api: double === null || !double.success
+                    ? { kind: 'stripe' }
+                    : { kind: 'double', url: double.data }
+            },
+        missing: inProduction ? [] : [...MAIL, ...STRIPE].filter((name) => input[name] === undefined),
+        product: own.data
+    };
+}

package/dist/server/endpoints.d.ts

@@ -0,0 +1,44 @@
+import type { RequestEvent } from '@sveltejs/kit';
+import { z } from 'zod';
+import { type Account } from './accounts.js';
+import type { Messages } from './messages.js';
+import { type Services } from './services.js';
+export declare const API_PATHS: {
+    readonly signup: "/api/v1/signup";
+    readonly account: "/api/v1/account";
+    readonly checkout: "/api/v1/billing/checkout";
+    readonly portal: "/api/v1/billing/portal";
+};
+type ApiPath = (typeof API_PATHS)[keyof typeof API_PATHS];
+export declare const API_METHODS: Record<ApiPath, string>;
+export declare function accountJson(account: Account): {
+    id: string;
+    email: string;
+    email_verified: boolean;
+    created_at: string;
+};
+/** The account of the bearer key, counted against the limit of the key. */
+export declare function apiAccount(s: Services, event: {
+    request: Request;
+}): Promise<{
+    account: Account;
+    keyId: string;
+}>;
+/** The body of the sign-up, every problem in the language of the product. */
+export declare function signupBody(m: Messages, terms: string): z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    accept_terms: z.ZodLiteral<true>;
+    acting_for_business: z.ZodLiteral<true>;
+    via: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The body of a Checkout over the API: a price of the catalog by its lookup key, and a quantity,
+ * which the price decides on (checkout below).
+ */
+export declare function checkoutBody(m: Messages): z.ZodObject<{
+    price: z.ZodString;
+    quantity: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/** The answer of a path of the baukasten's API, or null for any other path. */
+export declare function serveApi(s: Services, event: RequestEvent): Promise<Response> | null;
+export {};