@shaferllc/keel 0.78.2 → 0.80.0

package/dist/billing/migration.js

@@ -0,0 +1,68 @@
+/**
+ * The billing schema — gateway-neutral so one set of tables serves Stripe and
+ * Paddle. `subscriptions` and `subscription_items` are created through the
+ * fluent builder; the columns added to the existing billable table (`users`)
+ * and the secondary indexes go through `schema.raw()` because the builder has
+ * no `alterTable`/`index` (see src/core/migrations.ts).
+ *
+ * The `ADD COLUMN` / `CREATE INDEX` SQL is kept to the intersection that sqlite,
+ * mysql, and postgres all accept, and each runs exactly once (the migrator
+ * tracks applied migrations by name).
+ */
+export function billingMigration(billableTable = "users") {
+    return {
+        name: "billing_00_create_subscriptions",
+        async up(schema) {
+            await schema.createTable("subscriptions", (t) => {
+                t.id();
+                t.integer("billable_id");
+                t.string("billable_type").default("User");
+                t.string("type", 64).default("default");
+                t.string("gateway", 32);
+                t.string("provider_id").unique();
+                t.string("provider_status", 64);
+                t.json("provider_price").nullable();
+                t.integer("quantity").nullable();
+                t.timestamp("trial_ends_at").nullable();
+                t.timestamp("starts_at").nullable();
+                t.timestamp("ends_at").nullable();
+                t.timestamp("paused_at").nullable();
+                t.timestamps();
+            });
+            await schema.createTable("subscription_items", (t) => {
+                t.id();
+                t.integer("subscription_id");
+                t.string("provider_id").unique();
+                t.string("provider_product");
+                t.string("provider_price");
+                t.integer("quantity").nullable();
+                t.timestamps();
+            });
+            await schema.raw("CREATE INDEX idx_subscriptions_billable ON subscriptions (billable_id, billable_type)");
+            await schema.raw("CREATE INDEX idx_subscription_items_subscription ON subscription_items (subscription_id)");
+            // Billing columns on the billable (customer) table.
+            for (const col of [
+                "billing_gateway VARCHAR(32)",
+                "billing_customer_id VARCHAR(255)",
+                "pm_type VARCHAR(32)",
+                "pm_last_four VARCHAR(8)",
+                "trial_ends_at TIMESTAMP",
+            ]) {
+                await schema.raw(`ALTER TABLE ${billableTable} ADD COLUMN ${col}`);
+            }
+        },
+        async down(schema) {
+            await schema.dropTable("subscription_items");
+            await schema.dropTable("subscriptions");
+            for (const col of [
+                "billing_gateway",
+                "billing_customer_id",
+                "pm_type",
+                "pm_last_four",
+                "trial_ends_at",
+            ]) {
+                await schema.raw(`ALTER TABLE ${billableTable} DROP COLUMN ${col}`).catch(() => { });
+            }
+        },
+    };
+}

package/dist/billing/provider.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Keel Billing — a Cashier-style port covering Stripe and Paddle, shipped as a
+ * Keel package. One line in `bootstrap/providers.ts` turns it on:
+ *
+ *   app.register(BillingServiceProvider)
+ *
+ * `register()` merges config, wires the gateway drivers onto a manager, installs
+ * that manager as the module singleton (so `Billable` models can reach it
+ * without DI), contributes the schema migration, and declares the publishable
+ * config stub. `boot()` mounts the webhook route.
+ */
+import { PackageProvider } from "../core/package.js";
+export declare class BillingServiceProvider extends PackageProvider {
+    readonly name = "billing";
+    private config;
+    private manager;
+    register(): void;
+    boot(): void;
+    shutdown(): void;
+}

package/dist/billing/provider.js

@@ -0,0 +1,42 @@
+/**
+ * Keel Billing — a Cashier-style port covering Stripe and Paddle, shipped as a
+ * Keel package. One line in `bootstrap/providers.ts` turns it on:
+ *
+ *   app.register(BillingServiceProvider)
+ *
+ * `register()` merges config, wires the gateway drivers onto a manager, installs
+ * that manager as the module singleton (so `Billable` models can reach it
+ * without DI), contributes the schema migration, and declares the publishable
+ * config stub. `boot()` mounts the webhook route.
+ */
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { PackageProvider } from "../core/package.js";
+import { resolveConfig, defaultConfig } from "./config.js";
+import { BillingManager, setBilling } from "./manager.js";
+import { registerDefaultGateways } from "./drivers/index.js";
+import { billingMigration } from "./migration.js";
+import { registerBillingRoutes } from "./routes.js";
+const here = dirname(fileURLToPath(import.meta.url));
+export class BillingServiceProvider extends PackageProvider {
+    name = "billing";
+    config;
+    manager;
+    register() {
+        this.mergeConfig("billing", defaultConfig);
+        this.config = resolveConfig();
+        this.manager = new BillingManager(this.config);
+        registerDefaultGateways(this.manager);
+        setBilling(this.manager);
+        this.app.instance(BillingManager, this.manager);
+        // Cashier targets the standard `users` billable table.
+        this.migrations([billingMigration("users")]);
+        this.publishes({ [join(here, "billing.config.stub")]: "config/billing.ts" }, "billing-config");
+    }
+    boot() {
+        this.routes((r) => registerBillingRoutes(r, this.config.webhook.path));
+    }
+    shutdown() {
+        setBilling(undefined);
+    }
+}

package/dist/billing/routes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The billing HTTP surface: one webhook endpoint per gateway. The raw request
+ * body is read with `c.req.text()` (never `c.req.json()` first — the body stream
+ * is single-use and signature verification needs the exact bytes), and the
+ * `:gateway` segment selects which driver verifies it.
+ *
+ * Mounted by the provider at the configured `webhook.path` — e.g.
+ * `POST /billing/webhook/stripe`.
+ */
+import type { Router } from "../core/http/router.js";
+export declare function registerBillingRoutes(r: Router, webhookPath: string): void;

package/dist/billing/routes.js

@@ -0,0 +1,21 @@
+/**
+ * The billing HTTP surface: one webhook endpoint per gateway. The raw request
+ * body is read with `c.req.text()` (never `c.req.json()` first — the body stream
+ * is single-use and signature verification needs the exact bytes), and the
+ * `:gateway` segment selects which driver verifies it.
+ *
+ * Mounted by the provider at the configured `webhook.path` — e.g.
+ * `POST /billing/webhook/stripe`.
+ */
+import { handleWebhook } from "./webhooks.js";
+export function registerBillingRoutes(r, webhookPath) {
+    const base = "/" + webhookPath.replace(/^\/|\/$/g, "");
+    r.post(`${base}/:gateway`, async (c) => {
+        const gateway = c.req.param("gateway") ?? "";
+        const rawBody = await c.req.text();
+        const result = await handleWebhook(gateway, rawBody, (name) => c.req.header(name));
+        if (!result.ok)
+            return c.json({ received: false }, 400);
+        return c.json({ received: true });
+    }).name("webhook");
+}

package/dist/billing/subscription-item.d.ts

@@ -0,0 +1,18 @@
+/**
+ * One line of a subscription — a single price and its quantity. A single-price
+ * subscription has exactly one item; a multi-product subscription has several.
+ * Mirrors Cashier's `subscription_items` table.
+ */
+import { Model } from "../core/model.js";
+import type { Casts } from "../core/casts.js";
+export declare class SubscriptionItem extends Model {
+    static table: string;
+    static timestamps: boolean;
+    static casts: Casts;
+    id: number;
+    subscription_id: number;
+    provider_id: string;
+    provider_product: string;
+    provider_price: string;
+    quantity: number | null;
+}

package/dist/billing/subscription-item.js

@@ -0,0 +1,11 @@
+/**
+ * One line of a subscription — a single price and its quantity. A single-price
+ * subscription has exactly one item; a multi-product subscription has several.
+ * Mirrors Cashier's `subscription_items` table.
+ */
+import { Model } from "../core/model.js";
+export class SubscriptionItem extends Model {
+    static table = "subscription_items";
+    static timestamps = true;
+    static casts = { quantity: "int" };
+}

package/dist/billing/subscription.d.ts

@@ -0,0 +1,85 @@
+/**
+ * A subscription — the local mirror of a gateway subscription, and the object
+ * you act on. Status questions (`active`, `onTrial`, `onGracePeriod`, …) are
+ * answered from local columns; mutations (`swap`, `updateQuantity`, `cancel`,
+ * `resume`) call the active gateway and then sync the result back.
+ *
+ *   if (subscription.onGracePeriod()) await subscription.resume();
+ *   await subscription.swap("price_pro");
+ *   await subscription.incrementQuantity(2);
+ */
+import { Model } from "../core/model.js";
+import type { Casts } from "../core/casts.js";
+import { SubscriptionItem } from "./subscription-item.js";
+import type { GatewaySubscription, PriceRef } from "./gateway.js";
+/** A price argument: a bare id, or `{ price, quantity }`. */
+export type PriceArg = string | PriceRef;
+export declare function toRefs(prices: PriceArg | PriceArg[]): PriceRef[];
+export declare class Subscription extends Model {
+    static table: string;
+    static timestamps: boolean;
+    static casts: Casts;
+    id: number;
+    billable_id: number;
+    billable_type: string;
+    type: string;
+    gateway: string;
+    provider_id: string;
+    provider_status: string;
+    provider_price: string[] | null;
+    quantity: number | null;
+    trial_ends_at: Date | null;
+    starts_at: Date | null;
+    ends_at: Date | null;
+    paused_at: Date | null;
+    /** The subscription's line items. */
+    items(): import("../core/relations.js").HasMany<SubscriptionItem>;
+    /** On an unexpired trial. */
+    onTrial(): boolean;
+    hasExpiredTrial(): boolean;
+    /** Cancellation has been initiated (whether or not the grace period is over). */
+    canceled(): boolean;
+    /** Canceled, but the paid period hasn't elapsed yet — still usable. */
+    onGracePeriod(): boolean;
+    /** Cancellation is complete and the period has elapsed. */
+    ended(): boolean;
+    paused(): boolean;
+    /** The gateway reports a valid, live status and it hasn't ended. */
+    active(): boolean;
+    /** Active and past any trial. */
+    recurring(): boolean;
+    /** Usable right now: active, on trial, or within the grace period. */
+    valid(): boolean;
+    hasIncompletePayment(): boolean;
+    /** Whether this subscription includes the given price. */
+    hasPrice(price: string): boolean;
+    /** Swap to a new price (or set of prices). */
+    swap(prices: PriceArg | PriceArg[], opts?: {
+        prorate?: boolean;
+    }): Promise<this>;
+    incrementQuantity(count?: number): Promise<this>;
+    decrementQuantity(count?: number): Promise<this>;
+    updateQuantity(quantity: number, opts?: {
+        prorate?: boolean;
+    }): Promise<this>;
+    /** Cancel at period end — keeps access through the grace period. */
+    cancel(): Promise<this>;
+    /** Cancel immediately. */
+    cancelNow(): Promise<this>;
+    /** Resume a subscription still within its grace period. */
+    resume(): Promise<this>;
+    /** End the trial immediately (local state; the next invoice bills right away). */
+    endTrial(): Promise<this>;
+    /** Extend (or set) the trial end. */
+    extendTrial(until: Date): Promise<this>;
+    /** The gateway this subscription lives on. */
+    private gw;
+    /**
+     * Fold a gateway subscription back into local columns + items, then persist.
+     * The single source of truth for status flows through here (also used by the
+     * webhook handler).
+     */
+    syncFromGateway(remote: GatewaySubscription): Promise<this>;
+    /** Replace this subscription's items with the gateway's current set. */
+    private syncItems;
+}

package/dist/billing/subscription.js

@@ -0,0 +1,157 @@
+/**
+ * A subscription — the local mirror of a gateway subscription, and the object
+ * you act on. Status questions (`active`, `onTrial`, `onGracePeriod`, …) are
+ * answered from local columns; mutations (`swap`, `updateQuantity`, `cancel`,
+ * `resume`) call the active gateway and then sync the result back.
+ *
+ *   if (subscription.onGracePeriod()) await subscription.resume();
+ *   await subscription.swap("price_pro");
+ *   await subscription.incrementQuantity(2);
+ */
+import { Model } from "../core/model.js";
+import { billing } from "./manager.js";
+import { SubscriptionItem } from "./subscription-item.js";
+/** Provider statuses we treat as "the subscription is live". */
+const ACTIVE_STATUSES = new Set(["active", "trialing"]);
+/** Provider statuses that need the customer to finish a payment. */
+const INCOMPLETE_STATUSES = new Set(["incomplete", "past_due", "unpaid"]);
+export function toRefs(prices) {
+    const list = Array.isArray(prices) ? prices : [prices];
+    return list.map((p) => (typeof p === "string" ? { price: p } : p));
+}
+export class Subscription extends Model {
+    static table = "subscriptions";
+    static timestamps = true;
+    static casts = {
+        provider_price: "json",
+        quantity: "int",
+        trial_ends_at: "date",
+        starts_at: "date",
+        ends_at: "date",
+        paused_at: "date",
+    };
+    /** The subscription's line items. */
+    items() {
+        return this.hasMany(SubscriptionItem);
+    }
+    /* ------------------------------- status ------------------------------- */
+    /** On an unexpired trial. */
+    onTrial() {
+        return this.trial_ends_at != null && this.trial_ends_at.getTime() > Date.now();
+    }
+    hasExpiredTrial() {
+        return this.trial_ends_at != null && this.trial_ends_at.getTime() <= Date.now();
+    }
+    /** Cancellation has been initiated (whether or not the grace period is over). */
+    canceled() {
+        return this.ends_at != null;
+    }
+    /** Canceled, but the paid period hasn't elapsed yet — still usable. */
+    onGracePeriod() {
+        return this.ends_at != null && this.ends_at.getTime() > Date.now();
+    }
+    /** Cancellation is complete and the period has elapsed. */
+    ended() {
+        return this.canceled() && !this.onGracePeriod();
+    }
+    paused() {
+        return this.provider_status === "paused" || this.paused_at != null;
+    }
+    /** The gateway reports a valid, live status and it hasn't ended. */
+    active() {
+        return ACTIVE_STATUSES.has(this.provider_status) && !this.ended() && !this.paused();
+    }
+    /** Active and past any trial. */
+    recurring() {
+        return this.active() && !this.onTrial();
+    }
+    /** Usable right now: active, on trial, or within the grace period. */
+    valid() {
+        return this.active() || this.onTrial() || this.onGracePeriod();
+    }
+    hasIncompletePayment() {
+        return INCOMPLETE_STATUSES.has(this.provider_status);
+    }
+    /** Whether this subscription includes the given price. */
+    hasPrice(price) {
+        return (this.provider_price ?? []).includes(price);
+    }
+    /* ------------------------------- actions ------------------------------ */
+    /** Swap to a new price (or set of prices). */
+    async swap(prices, opts) {
+        const result = await this.gw().swapSubscription(this.provider_id, {
+            items: toRefs(prices),
+            ...(opts?.prorate != null ? { prorate: opts.prorate } : {}),
+        });
+        return this.syncFromGateway(result);
+    }
+    async incrementQuantity(count = 1) {
+        return this.updateQuantity((this.quantity ?? 1) + count);
+    }
+    async decrementQuantity(count = 1) {
+        return this.updateQuantity(Math.max(0, (this.quantity ?? 1) - count));
+    }
+    async updateQuantity(quantity, opts) {
+        const result = await this.gw().updateQuantity(this.provider_id, quantity, opts);
+        return this.syncFromGateway(result);
+    }
+    /** Cancel at period end — keeps access through the grace period. */
+    async cancel() {
+        return this.syncFromGateway(await this.gw().cancelSubscription(this.provider_id));
+    }
+    /** Cancel immediately. */
+    async cancelNow() {
+        return this.syncFromGateway(await this.gw().cancelSubscription(this.provider_id, { now: true }));
+    }
+    /** Resume a subscription still within its grace period. */
+    async resume() {
+        return this.syncFromGateway(await this.gw().resumeSubscription(this.provider_id));
+    }
+    /** End the trial immediately (local state; the next invoice bills right away). */
+    async endTrial() {
+        this.trial_ends_at = null;
+        if (this.provider_status === "trialing")
+            this.provider_status = "active";
+        return this.save();
+    }
+    /** Extend (or set) the trial end. */
+    async extendTrial(until) {
+        this.trial_ends_at = until;
+        return this.save();
+    }
+    /* ------------------------------ internals ----------------------------- */
+    /** The gateway this subscription lives on. */
+    gw() {
+        return billing().gateway(this.gateway);
+    }
+    /**
+     * Fold a gateway subscription back into local columns + items, then persist.
+     * The single source of truth for status flows through here (also used by the
+     * webhook handler).
+     */
+    async syncFromGateway(remote) {
+        this.provider_status = remote.status;
+        this.provider_price = remote.items.map((i) => i.price);
+        this.quantity = remote.quantity ?? remote.items[0]?.quantity ?? this.quantity ?? null;
+        this.trial_ends_at = remote.trialEndsAt ?? null;
+        this.ends_at = remote.endsAt ?? null;
+        await this.save();
+        await this.syncItems(remote);
+        return this;
+    }
+    /** Replace this subscription's items with the gateway's current set. */
+    async syncItems(remote) {
+        if (this.id == null)
+            return;
+        await SubscriptionItem.query().where("subscription_id", this.id).delete();
+        for (const item of remote.items) {
+            await SubscriptionItem.create({
+                subscription_id: this.id,
+                provider_id: item.id,
+                provider_product: item.product,
+                provider_price: item.price,
+                quantity: item.quantity ?? 1,
+            });
+        }
+    }
+}

package/dist/billing/webhooks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The webhook handler. It verifies the raw body against the gateway's signing
+ * secret, emits `billing.webhook.received`, and — when the event concerns a
+ * subscription — folds the gateway's state into the local `Subscription` row and
+ * emits the matching `billing.subscription.*` event.
+ *
+ * A known subscription (already in the DB) is always synced. An unknown one
+ * (e.g. Paddle's create-on-checkout) is created only if the app registered a
+ * billable resolver with `resolveBillableUsing()` — otherwise it's left to the
+ * app's own `listen("billing.webhook.received", …)`.
+ */
+import type { HeaderBag, WebhookEvent } from "./gateway.js";
+import "./events.js";
+export interface WebhookResult {
+    ok: boolean;
+    status: 200 | 400;
+    event?: WebhookEvent;
+}
+/** Maps a gateway customer id to a local billable, so unknown subs can be created. */
+export type BillableResolver = (customerId: string, gateway: string) => Promise<{
+    id: number | string;
+    type: string;
+} | null>;
+/** Register how to find the billable for a gateway customer (optional). */
+export declare function resolveBillableUsing(fn: BillableResolver | undefined): void;
+export declare function handleWebhook(gatewayName: string, rawBody: string, headers: HeaderBag): Promise<WebhookResult>;

package/dist/billing/webhooks.js

@@ -0,0 +1,75 @@
+/**
+ * The webhook handler. It verifies the raw body against the gateway's signing
+ * secret, emits `billing.webhook.received`, and — when the event concerns a
+ * subscription — folds the gateway's state into the local `Subscription` row and
+ * emits the matching `billing.subscription.*` event.
+ *
+ * A known subscription (already in the DB) is always synced. An unknown one
+ * (e.g. Paddle's create-on-checkout) is created only if the app registered a
+ * billable resolver with `resolveBillableUsing()` — otherwise it's left to the
+ * app's own `listen("billing.webhook.received", …)`.
+ */
+import { emit } from "../core/helpers.js";
+import { billing } from "./manager.js";
+import { Subscription } from "./subscription.js";
+import "./events.js";
+let resolver;
+/** Register how to find the billable for a gateway customer (optional). */
+export function resolveBillableUsing(fn) {
+    resolver = fn;
+}
+export async function handleWebhook(gatewayName, rawBody, headers) {
+    const manager = billing();
+    const gateway = manager.gateway(gatewayName);
+    const secret = manager.webhookSecret(gatewayName);
+    const event = await gateway.verifyWebhook(rawBody, headers, secret);
+    if (!event)
+        return { ok: false, status: 400 };
+    await emit("billing.webhook.received", {
+        gateway: gatewayName,
+        type: event.type,
+        id: event.id,
+    });
+    if (event.subscription)
+        await syncSubscription(gatewayName, event);
+    return { ok: true, status: 200, event };
+}
+async function syncSubscription(gatewayName, event) {
+    const remote = event.subscription;
+    const existing = (await Subscription.query()
+        .where("provider_id", remote.id)
+        .first());
+    if (existing) {
+        const subscription = new Subscription(existing);
+        await subscription.syncFromGateway(remote);
+        const deleted = event.type.includes("deleted") || subscription.ended();
+        await emit(deleted ? "billing.subscription.deleted" : "billing.subscription.updated", {
+            gateway: gatewayName,
+            subscriptionId: subscription.id,
+            providerId: subscription.provider_id,
+            status: subscription.provider_status,
+        });
+        return;
+    }
+    if (!resolver || !event.customer)
+        return;
+    const target = await resolver(event.customer, gatewayName);
+    if (!target)
+        return;
+    const subscription = await Subscription.create({
+        billable_id: target.id,
+        billable_type: target.type,
+        type: "default",
+        gateway: gatewayName,
+        provider_id: remote.id,
+        provider_status: remote.status,
+        starts_at: new Date(),
+    });
+    await subscription.syncFromGateway(remote);
+    await emit("billing.subscription.created", {
+        gateway: gatewayName,
+        subscriptionId: subscription.id,
+        providerId: subscription.provider_id,
+        status: subscription.provider_status,
+    });
+}

package/dist/core/binding.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Route model binding — a `:user` in the path arrives as a `User`, not a string.
+ *
+ *   bindModel("user", User);
+ *
+ *   router.get("/users/:user", (c) => {
+ *     const user = boundModel(User);   // already fetched. Not a string, not null.
+ *     return c.json(user);
+ *   });
+ *
+ * The row is looked up **before the handler runs**, and a miss is a 404 there and
+ * then. That's the whole value: the handler never sees a null, so it never has to
+ * remember to check for one — and "forgot the 404" stops being a bug you can write.
+ *
+ * Bind by another column when the URL isn't the id:
+ *
+ *   bindModel("post", Post, { key: "slug" });     // /posts/hello-world
+ *
+ * Constrain what's reachable (row-level security — a row outside the scope 404s,
+ * so it can't be reached by guessing an id):
+ *
+ *   bindModel("post", Post, { scope: (q, c) => q.where("authorId", currentUserId(c)) });
+ *
+ * Or resolve it yourself, for anything that isn't a model:
+ *
+ *   bindRoute("tenant", (slug) => tenants.get(slug));
+ */
+import type { MiddlewareHandler } from "hono";
+import type { Ctx } from "./http/router.js";
+import type { QueryBuilder, Row } from "./database.js";
+import type { Model } from "./model.js";
+/** A `Model` subclass — the class itself, with its statics. */
+export type ModelClass<T extends Model = Model> = {
+    new (row?: Row): T;
+    table: string;
+    primaryKey: string;
+    query(): QueryBuilder;
+};
+export interface BindingOptions<T extends Model = Model> {
+    /** The column the URL segment matches. Default: the model's `primaryKey`. */
+    key?: string;
+    /**
+     * Constrain what's findable. A row outside the scope is a 404 — so it can't be
+     * reached by guessing an id, which is what makes this security rather than a
+     * filter.
+     */
+    scope?: (query: QueryBuilder, c: Ctx) => QueryBuilder | void;
+    /**
+     * What to do when nothing matches. Default: throw a 404. Return a value to
+     * substitute one instead.
+     */
+    missing?: (value: string, c: Ctx) => T | never;
+}
+/**
+ * Bind a route parameter to a model. `:user` becomes a `User`; a row that doesn't
+ * exist (or is outside `scope`) is a 404 before your handler runs.
+ */
+export declare function bindModel<T extends Model>(param: string, model: ModelClass<T>, options?: BindingOptions<T>): void;
+/**
+ * Bind a route parameter to anything at all — a tenant from a map, a feature flag,
+ * a value from an API. Returning `undefined` or `null` is a 404.
+ */
+export declare function bindRoute(param: string, resolve: (value: string, c: Ctx) => unknown | Promise<unknown>): void;
+/** Whether a parameter has a binding registered. */
+export declare function hasBinding(param: string): boolean;
+/** Drop every binding — a clean slate between tests. */
+export declare function clearBindings(): void;
+/** The parameter names in a route pattern: `/users/:user/posts/:post` → both. */
+export declare function paramNames(pattern: string): string[];
+/**
+ * Resolve this route's bound parameters and stash them on the request. Installed
+ * by the HTTP kernel for any route whose pattern has a bound parameter — so the
+ * work is skipped entirely for routes that don't.
+ *
+ * @internal
+ */
+export declare function resolveBindings(params: string[], c: Ctx): Promise<void> | void;
+/** Middleware that resolves the bound params of a route pattern. @internal */
+export declare function bindingMiddleware(pattern: string): MiddlewareHandler | undefined;
+/** The raw bound value for a parameter, if any. */
+export declare function boundValue<T = unknown>(param: string, c?: Ctx): T | undefined;
+/**
+ * The model bound to this route — already fetched, never null.
+ *
+ *   router.get("/posts/:post", () => {
+ *     const post = boundModel(Post);   // a Post, guaranteed
+ *   });
+ *
+ * Pass the parameter name when one model is bound to several (`/users/:user/friends/:friend`).
+ */
+export declare function boundModel<T extends Model>(model: ModelClass<T>, param?: string, c?: Ctx): T;