@tollwyn/baukasten 0.0.2 → 1.2.2

package/dist/server/ports.d.ts

@@ -0,0 +1,273 @@
+import type pg from 'pg';
+/** Anything that runs SQL: the pool, or one transaction. */
+export interface Queryable {
+    query<T extends pg.QueryResultRow = pg.QueryResultRow>(sql: string, params?: unknown[]): Promise<T[]>;
+}
+/**
+ * The pool of a product, shared by the baukasten and the product. Neon suspends when no connection
+ * is open, so a connection goes back after a short idle time, and nothing opens one without work.
+ */
+export interface Db extends Queryable {
+    /** Runs `fn` in one transaction: it commits when `fn` resolves and rolls back when it throws. */
+    transaction<T>(fn: (tx: Queryable) => Promise<T>): Promise<T>;
+    /**
+     * The same pool for queries that must end within `ms`: a query that runs out fails, and its
+     * connection is dropped instead of waiting for a database that hangs.
+     */
+    withTimeout(ms: number): Queryable;
+    /** Physical connections the pool has opened since it was created. */
+    connectionsOpened(): number;
+    close(): Promise<void>;
+}
+/** Randomness and password hashing for accounts; SHA-256 of a token needs no port. */
+export interface Secrets {
+    /** A fresh random secret for a session, a link or a key: 32 bytes, base64url, 43 characters. */
+    token(): string;
+    /** A slow, salted hash of a password, with its parameters, for the database. */
+    hashPassword(password: string): Promise<string>;
+    /** Whether the password fits a hash of hashPassword; as slow as hashing, whatever the answer. */
+    verifyPassword(password: string, stored: string): Promise<boolean>;
+}
+/** A mail of the product: plain text, from MAIL_FROM with MAIL_FROM_NAME. */
+export interface Mail {
+    to: string;
+    subject: string;
+    text: string;
+}
+export interface Mailer {
+    /**
+     * Sends one mail through the relay of the fleet, or, locally without SMTP, writes it with its
+     * links to the log. A failure throws MailFailed (mail.ts), whose message never names an address.
+     */
+    send(mail: Mail): Promise<void>;
+    /**
+     * Whether the relay greets: a connection and EHLO, without a login and without a mail, for
+     * /health/deep; MailFailed as `send`. Without SMTP there is nothing to check.
+     */
+    check(): Promise<void>;
+}
+/** A product at Stripe as the catalog compares it. */
+export interface StripeProduct {
+    id: string;
+    name: string;
+    active: boolean;
+}
+/** An active price at Stripe: once, or per interval. */
+export type StripePrice = {
+    id: string;
+    product: string;
+    /** In the smallest unit of the currency; null for a price that is not a fixed amount. */
+    amount: number | null;
+    /** Small letters, as Stripe writes it. */
+    currency: string;
+} & ({
+    type: 'one_time';
+} | {
+    type: 'recurring';
+    interval: string;
+    intervalCount: number;
+});
+/** A new price that takes over the lookup key from the price that held it. */
+export type NewPrice = {
+    product: string;
+    lookupKey: string;
+    amount: number;
+    currency: string;
+} & ({
+    type: 'one_time';
+} | {
+    type: 'recurring';
+    interval: 'month' | 'year';
+});
+/** What the baukasten sets of the default configuration of the customer portal, as the API takes it. */
+export interface PortalConfiguration {
+    business_profile: {
+        headline: string;
+        privacy_policy_url: string;
+        terms_of_service_url: string;
+    };
+    default_return_url: string;
+    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: {
+            enabled: false;
+        } | {
+            enabled: true;
+            default_allowed_updates: ('price' | 'quantity')[];
+            proration_behavior: 'create_prorations';
+            products: {
+                product: string;
+                prices: string[];
+                adjustable_quantity: {
+                    enabled: false;
+                } | {
+                    enabled: true;
+                    minimum: number;
+                    maximum: number;
+                };
+            }[];
+        };
+    };
+}
+export type SubscriptionStatus = 'incomplete' | 'incomplete_expired' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid' | 'paused';
+/** A subscription at Stripe with its one item. */
+export interface StripeSubscription {
+    id: string;
+    customerId: string;
+    status: SubscriptionStatus;
+    product: string;
+    /** The price, and its lookup key; a price that gave its key to a newer one has none. */
+    price: {
+        id: string;
+        lookupKey: string | null;
+    };
+    quantity: number;
+    /** The last invoice of the subscription; a new one has its first. */
+    latestInvoice: string | null;
+}
+/** A Checkout page for one price; the customer accepts the terms there. */
+export type CheckoutRequest = {
+    customerId: string;
+    accountId: string;
+    priceId: string;
+    successUrl: string;
+    cancelUrl: string;
+    /** The sentence by the box for the terms, in Markdown with the link to them. */
+    termsMessage: string;
+    expiresAt: Date;
+} & ({
+    mode: 'subscription';
+    quantity: number;
+    /** Whether the customer may change the quantity in Checkout, and up to how many. */
+    adjustable: {
+        kind: 'fixed';
+    } | {
+        kind: 'up to';
+        max: number;
+    };
+} | {
+    mode: 'payment';
+    product: string;
+    lookupKey: string;
+});
+/** A Checkout session of the webhook: of a subscription, of a purchase of this product, or other. */
+export type CheckoutSession = {
+    mode: 'subscription';
+    id: string;
+    customerId: string;
+    subscriptionId: string;
+} | {
+    mode: 'payment';
+    id: string;
+    customerId: string;
+    paid: boolean;
+    amount: number;
+    currency: string;
+    /** The product and the lookup key of the price, as the Checkout of the baukasten names them. */
+    product: string;
+    lookupKey: string;
+} | {
+    mode: 'other';
+    id: string;
+};
+export type StripeEvent = {
+    id: string;
+    type: string;
+    created: Date;
+} & ({
+    kind: 'checkout';
+    session: CheckoutSession;
+} | {
+    kind: 'subscription';
+    subscriptionId: string;
+    customerId: string;
+} | {
+    kind: 'invoice';
+    invoice: {
+        id: string;
+        customerId: string;
+        amount: number;
+        currency: string;
+        paidAt: Date;
+    };
+} | {
+    kind: 'other';
+});
+/**
+ * Stripe, with the key of the product. A failure throws StripeFailed (billing.ts), whose message
+ * names what Stripe called it and never the key.
+ */
+export interface StripeApi {
+    /** The product of this id, archived or not; null when there is none. */
+    product(id: string): Promise<StripeProduct | null>;
+    createProduct(product: {
+        id: string;
+        name: string;
+    }): Promise<void>;
+    /** Sets the name and makes the product active again. */
+    updateProduct(product: {
+        id: string;
+        name: string;
+    }): Promise<void>;
+    /** The active price of the lookup key; null when no active price holds it. */
+    activePrice(lookupKey: string): Promise<StripePrice | null>;
+    /** Returns the id of the new price. */
+    createPrice(price: NewPrice): Promise<string>;
+    /**
+     * The default configuration of the customer portal as Stripe shows it, with the products of its
+     * subscription updates; null while the Dashboard never saved one in this mode.
+     */
+    defaultPortal(): Promise<{
+        id: string;
+        configuration: unknown;
+    } | null>;
+    updatePortal(id: string, configuration: PortalConfiguration): Promise<void>;
+    webhookEndpoints(): Promise<{
+        id: string;
+        url: string;
+        enabled: boolean;
+    }[]>;
+    /** Creates a customer with this address, marked with the account; returns its id. */
+    createCustomer(customer: {
+        email: string;
+        accountId: string;
+    }): Promise<string>;
+    updateCustomerEmail(customerId: string, email: string): Promise<void>;
+    /** Every subscription of the customer, ended or not, with its status. */
+    subscriptionsOf(customerId: string): Promise<{
+        id: string;
+        status: SubscriptionStatus;
+    }[]>;
+    subscription(id: string): Promise<StripeSubscription>;
+    /** Ends a subscription at once; `missing` when Stripe does not know it. */
+    cancelSubscription(id: string): Promise<'canceled' | 'missing'>;
+    /** Returns the address of the Checkout page. */
+    createCheckout(request: CheckoutRequest): Promise<string>;
+    /** Returns the address of the customer portal. */
+    createPortalSession(session: {
+        customerId: string;
+        configurationId: string;
+        returnUrl: string;
+    }): Promise<string>;
+    /** The event of a webhook request, when its signature fits the secret of the webhook. */
+    event(payload: string, signature: string | null): {
+        kind: 'event';
+        event: StripeEvent;
+    } | {
+        kind: 'invalid';
+    };
+}

package/dist/server/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/server/runs.d.ts

@@ -0,0 +1,30 @@
+import type { Log } from './log.js';
+import type { Db } from './ports.js';
+export interface Run {
+    /** There is work: the next beat calls the work of the run. */
+    mark(): void;
+    /** Beats every `everyMs` from now on; the timer keeps no process alive. */
+    start(context: {
+        db: Db;
+        log: Log;
+    }): void;
+    /** Stops the beats and waits for a beat that is still running. */
+    stop(): Promise<void>;
+}
+export interface RunOptions {
+    name: string;
+    everyMs: number;
+    /** The work of a beat with the pool and the log of the product. */
+    work: (context: {
+        db: Db;
+        log: Log;
+    }) => Promise<void>;
+}
+export declare function periodic(options: RunOptions): Run;
+/**
+ * The run with its single beat, which the timer calls: without a mark, or while the last beat still
+ * runs, a beat returns at once. The tests beat by hand.
+ */
+export declare function beating(options: RunOptions): Run & {
+    tick(): Promise<void>;
+};

package/dist/server/runs.js

@@ -0,0 +1,55 @@
+export function periodic(options) {
+    return beating(options);
+}
+/**
+ * The run with its single beat, which the timer calls: without a mark, or while the last beat still
+ * runs, a beat returns at once. The tests beat by hand.
+ */
+export function beating(options) {
+    const { name, everyMs, work } = options;
+    let state = { kind: 'waiting' };
+    let marked = false;
+    let running = null;
+    async function tick() {
+        if (state.kind === 'waiting')
+            throw new Error(`run ${name} beats before it was started`);
+        if (state.kind === 'stopped')
+            throw new Error(`run ${name} beats after it was stopped`);
+        if (running !== null || !marked)
+            return;
+        const { db, log } = state;
+        // Cleared before the work: a mark set while it runs calls it again at the next beat.
+        marked = false;
+        running = work({ db, log }).catch((error) => {
+            marked = true;
+            log.error('run failed, it tries again', { run: name, error });
+        });
+        try {
+            await running;
+        }
+        finally {
+            running = null;
+        }
+    }
+    return {
+        mark() {
+            marked = true;
+        },
+        tick,
+        start({ db, log }) {
+            if (state.kind !== 'waiting')
+                throw new Error(`run ${name} was started before`);
+            const timer = setInterval(() => {
+                void tick();
+            }, everyMs);
+            timer.unref();
+            state = { kind: 'started', db, log, timer };
+        },
+        async stop() {
+            if (state.kind === 'started')
+                clearInterval(state.timer);
+            state = { kind: 'stopped' };
+            await running;
+        }
+    };
+}

package/dist/server/sales.d.ts

@@ -0,0 +1,38 @@
+import type { Log } from './log.js';
+import type { Queryable } from './ports.js';
+export declare const SALES_PATH = "/vertrieb/zahlen";
+/** The numbers of every referral tag, in this order. */
+export declare const SALES_NUMBERS: readonly ["Konten", "Zahlende"];
+export declare const KENNUNGEN_MAX = 500;
+export interface SalesNumbers {
+    stand: string;
+    je_kennung: {
+        kennung: string;
+        werte: {
+            name: string;
+            wert: number;
+        }[];
+        /** In the smallest unit of the currency; null without revenue. */
+        umsatz: {
+            cent: number;
+            waehrung: string;
+        } | null;
+    }[];
+}
+/** Numbers of the product by their name, each per account id. */
+export type ProductNumbers = Readonly<Record<string, Readonly<Record<string, number>>>>;
+/**
+ * Whether the request carries the bearer token. Both sides are hashed to the same length first, so
+ * the comparison takes the same time whatever was sent.
+ */
+export declare function bearerFits(authorization: string | null, token: string): boolean;
+/** The numbers of the product, checked: what does not fit would spoil the whole answer. */
+export declare function productNumbers(numbers: unknown): ProductNumbers;
+export declare function salesNumbers(db: Queryable, options: {
+    currency: string;
+    now: Date;
+    own: ProductNumbers;
+    /** With the live key only the accounts of the live mode count: the others are tests. */
+    count: 'all' | 'live';
+    log: Log;
+}): Promise<SalesNumbers>;

package/dist/server/sales.js

@@ -0,0 +1,132 @@
+// GET /vertrieb/zahlen answers in the form every product promises the delivery service, which
+// sales.db.test.ts holds.
+import { createHash, timingSafeEqual } from 'node:crypto';
+import { z } from 'zod';
+import { NO_VIA } from './via.js';
+export const SALES_PATH = '/vertrieb/zahlen';
+/** The numbers of every referral tag, in this order. */
+export const SALES_NUMBERS = ['Konten', 'Zahlende'];
+/** The delivery service takes at most this many numbers per referral tag. */
+const NUMBERS_MAX = 20;
+export const KENNUNGEN_MAX = 500;
+const reserved = new Set(SALES_NUMBERS);
+/** A name as it is shown; Postgres takes neither NUL nor a lone surrogate in JSONB. */
+const NAME = z
+    .string()
+    .min(1, 'is empty')
+    .max(60, 'is longer than 60 characters')
+    .regex(/^\S(?:.*\S)?$/u, 'starts or ends with a blank')
+    .regex(/^[^\p{Cc}\p{Cs}]+$/u, 'carries a control character')
+    .refine((name) => !reserved.has(name), 'is a number of the baukasten');
+const PRODUCT_NUMBERS = z
+    .record(z.string(), z.record(z.uuid(), z.int().min(0)))
+    .superRefine((numbers, ctx) => {
+    const names = Object.keys(numbers);
+    if (names.length > NUMBERS_MAX - SALES_NUMBERS.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `names more than ${NUMBERS_MAX - SALES_NUMBERS.length} numbers`
+        });
+    }
+    for (const name of names) {
+        for (const issue of NAME.safeParse(name).error?.issues ?? []) {
+            ctx.addIssue({ code: 'custom', path: [name], message: issue.message });
+        }
+    }
+});
+/**
+ * Whether the request carries the bearer token. Both sides are hashed to the same length first, so
+ * the comparison takes the same time whatever was sent.
+ */
+export function bearerFits(authorization, token) {
+    const given = /^Bearer (\S+)$/.exec(authorization ?? '')?.[1] ?? '';
+    const digest = (value) => createHash('sha256').update(value).digest();
+    return timingSafeEqual(digest(given), digest(token));
+}
+/** The numbers of the product, checked: what does not fit would spoil the whole answer. */
+export function productNumbers(numbers) {
+    const read = PRODUCT_NUMBERS.safeParse(numbers);
+    if (!read.success) {
+        const problems = read.error.issues.map((issue) => `${issue.path.join('.')} ${issue.message}`);
+        throw new Error(`the sales numbers of the product: ${problems.join('; ')}`);
+    }
+    return read.data;
+}
+/** First what brings money, then by the referral tag. */
+function byYield(a, b) {
+    const [aKonten = 0, aZahlende = 0] = a.values;
+    const [bKonten = 0, bZahlende = 0] = b.values;
+    return (bZahlende - aZahlende ||
+        b.cent - a.cent ||
+        bKonten - aKonten ||
+        (a.kennung < b.kennung ? -1 : a.kennung > b.kennung ? 1 : 0));
+}
+/**
+ * At most KENNUNGEN_MAX referral tags: the delivery service takes no more in one answer, and a tag
+ * is what a visitor writes into a link. The rest counts under ohne, so that every account and every
+ * franc is still in the answer.
+ */
+function withinLimit(counted, log) {
+    if (counted.length <= KENNUNGEN_MAX)
+        return counted;
+    const others = counted.filter((entry) => entry.kennung !== NO_VIA);
+    const kept = others.slice(0, KENNUNGEN_MAX - 1);
+    const folded = others.slice(KENNUNGEN_MAX - 1);
+    const without = counted.find((entry) => entry.kennung === NO_VIA);
+    const width = counted[0]?.values.length ?? 0;
+    const merged = [...folded, ...(without === undefined ? [] : [without])].reduce((sum, entry) => ({
+        kennung: NO_VIA,
+        values: sum.values.map((value, i) => value + (entry.values[i] ?? 0)),
+        cent: sum.cent + entry.cent
+    }), { kennung: NO_VIA, values: Array(width).fill(0), cent: 0 });
+    log.warn('sales: more Kennungen than the delivery service takes; the rest counted under ohne', {
+        folded: folded.length
+    });
+    return [...kept, merged].sort(byYield);
+}
+export async function salesNumbers(db, options) {
+    const names = Object.keys(options.own);
+    const own = Object.entries(options.own).flatMap(([name, perAccount]) => Object.entries(perAccount).map(([account, value]) => ({ name, account, value })));
+    const live = options.count === 'live';
+    const [accounts, revenue, counted] = await Promise.all([
+        db.query(`SELECT a.via, count(*)::int AS konten,
+				count(*) FILTER (WHERE
+					EXISTS (SELECT 1 FROM baukasten.invoices i WHERE i.account_id = a.id AND i.amount > 0)
+					OR EXISTS (SELECT 1 FROM baukasten.purchases p WHERE p.account_id = a.id AND p.amount > 0)
+				)::int AS zahlende
+			 FROM baukasten.accounts a WHERE (NOT $1 OR a.stripe_mode = 'live') GROUP BY a.via`, [live]),
+        db.query(`SELECT a.via, sum(paid.amount)::text AS cent FROM (
+				SELECT account_id, amount FROM baukasten.invoices WHERE currency = $1
+				UNION ALL SELECT account_id, amount FROM baukasten.purchases WHERE currency = $1
+			 ) paid JOIN baukasten.accounts a ON a.id = paid.account_id
+			 WHERE (NOT $2 OR a.stripe_mode = 'live') GROUP BY a.via`, [options.currency.toLowerCase(), live]),
+        db.query(`SELECT own.name, a.via, sum(own.value)::text AS value
+			 FROM unnest($1::text[], $2::uuid[], $3::bigint[]) AS own (name, account, value)
+			 JOIN baukasten.accounts a ON a.id = own.account
+			 WHERE (NOT $4 OR a.stripe_mode = 'live') GROUP BY own.name, a.via`, [own.map((n) => n.name), own.map((n) => n.account), own.map((n) => n.value), live])
+    ]);
+    const cents = new Map(revenue.map((row) => [row.via, Number(row.cent)]));
+    const values = new Map(counted.map((row) => [`${row.name}\n${row.via}`, Number(row.value)]));
+    const all = accounts
+        .map((row) => ({
+        kennung: row.via,
+        values: [
+            row.konten,
+            row.zahlende,
+            // The product counted each of its accounts: one it does not name has none.
+            ...names.map((name) => values.get(`${name}\n${row.via}`) ?? 0)
+        ],
+        // A referral tag without a payment in the currency has no row of revenue.
+        cent: cents.get(row.via) ?? 0
+    }))
+        .sort(byYield);
+    const numbers = [...SALES_NUMBERS, ...names];
+    return {
+        stand: options.now.toISOString(),
+        je_kennung: withinLimit(all, options.log).map((entry) => ({
+            kennung: entry.kennung,
+            werte: numbers.map((name, i) => ({ name, wert: entry.values[i] ?? 0 })),
+            umsatz: entry.cent > 0 ? { cent: entry.cent, waehrung: options.currency } : null
+        }))
+    };
+}

package/dist/server/services.d.ts

@@ -0,0 +1,57 @@
+import type { Product } from '../product.js';
+import { type Accounts, type DeleteHook, type SignUp } from './accounts.js';
+import type { Billing } from './billing.js';
+import type { Config } from './config.js';
+import type { LegalPages } from './legal/index.js';
+import { type Limits } from './limits.js';
+import type { Log } from './log.js';
+import type { Messages } from './messages.js';
+import type { Db, Mailer, Queryable } from './ports.js';
+export interface Services {
+    config: Config;
+    product: Product;
+    db: Db;
+    log: Log;
+    mail: Mailer;
+    limits: Limits;
+    accounts: Accounts;
+    billing: Billing;
+    messages: Messages;
+    /** The name of the terms a sign-up accepts. */
+    termsVersion: string;
+    /** Imprint, privacy policy and terms, written once at the start. */
+    legal: LegalPages;
+    deleteHook: DeleteHook;
+    /** The numbers of the product for GET /vertrieb/zahlen, unchecked: they come from its code. */
+    salesNumbers: (db: Queryable) => Promise<unknown>;
+    address(event: {
+        request: Request;
+        getClientAddress(): string;
+    }): string;
+    now: () => Date;
+}
+export declare function signUp(s: Services, email: string, via: string | null): SignUp;
+export type Sent = {
+    kind: 'sent';
+} | {
+    kind: 'failed';
+} | {
+    kind: 'limited';
+    seconds: number;
+};
+/**
+ * Sends the link to confirm the address, to set a new password, or to make `newEmail` the address,
+ * which gets the mail. Each recipient gets a few mails of the accounts an hour, whoever asks; the
+ * link is made only when the mail may go.
+ */
+export declare function sendLink(s: Services, account: {
+    id: string;
+    email: string;
+}, link: {
+    purpose: 'verify';
+} | {
+    purpose: 'reset';
+} | {
+    purpose: 'change_email';
+    newEmail: string;
+}): Promise<Sent>;

package/dist/server/services.js

@@ -0,0 +1,44 @@
+import { LINK_SECONDS, sha256, normalizeEmail } from './accounts.js';
+import { LIMITS } from './limits.js';
+import { deliver } from './mail.js';
+import { NO_VIA } from './via.js';
+export function signUp(s, email, via) {
+    return {
+        email,
+        termsVersion: s.termsVersion,
+        via: via ?? NO_VIA,
+        // Without Stripe nothing moves money, as in the test mode.
+        stripeMode: s.config.stripe.kind === 'stripe' ? s.config.stripe.mode : 'test'
+    };
+}
+const PAGES = {
+    verify: '/verify-email',
+    reset: '/reset-password',
+    change_email: '/confirm-email'
+};
+/**
+ * Sends the link to confirm the address, to set a new password, or to make `newEmail` the address,
+ * which gets the mail. Each recipient gets a few mails of the accounts an hour, whoever asks; the
+ * link is made only when the mail may go.
+ */
+export async function sendLink(s, account, link) {
+    const to = link.purpose === 'change_email' ? normalizeEmail(link.newEmail) : account.email;
+    const seconds = s.limits.take(`mails-to:${sha256(to).toString('hex')}`, LIMITS.mailsTo);
+    if (seconds > 0)
+        return { kind: 'limited', seconds };
+    const token = link.purpose === 'change_email'
+        ? await s.accounts.issueEmailChange(account.id, to)
+        : await s.accounts.issueLink(account.id, link.purpose);
+    const mail = {
+        verify: s.messages.mails.verify,
+        reset: s.messages.mails.reset,
+        change_email: s.messages.mails.change
+    }[link.purpose]({
+        name: s.config.name,
+        origin: s.config.publicOrigin,
+        link: `${s.config.publicOrigin}${PAGES[link.purpose]}?token=${token}`,
+        hours: LINK_SECONDS[link.purpose] / 3_600
+    });
+    const sent = await deliver(s.mail, s.log, { to, ...mail }, { kind: link.purpose, account: account.id });
+    return sent ? { kind: 'sent' } : { kind: 'failed' };
+}

package/dist/server/start.d.ts

@@ -0,0 +1,14 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+export type NodeHandler = (req: IncomingMessage, res: ServerResponse) => void;
+/**
+ * Open requests get this long after SIGTERM, the stop hooks of the product then this long; both end
+ * before the fixed start of the delivery service kills the product (stop-grace.test.ts).
+ */
+export declare const DRAIN_MS = 15000;
+export declare const STOP_MS = 10000;
+export declare function start(load: () => Promise<{
+    handler: NodeHandler;
+}>): Promise<void>;
+export declare function serve(load: () => Promise<{
+    handler: NodeHandler;
+}>, headers: Readonly<Record<string, string>>): Promise<void>;