better-supabase 0.12.0 → 0.14.0

package/dist/index-CxmVzT-3.d.ts

@@ -1,86 +0,0 @@
-import { SupabaseEnv } from "@supabase/server";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/env/index.d.ts
-/** Validated Supabase settings. Only `publicEnv()` of it is safe to ship to a browser. */
-interface BetterSupabaseEnv {
-  readonly url: string;
-  readonly publishableKey: string;
-  readonly secretKey?: string;
-  /** Named secret keys from `SUPABASE_SECRET_KEYS`, including `default` when `secretKey` is set. */
-  readonly secretKeys?: Readonly<Record<string, string>>;
-  /** `SUPABASE_JWKS_URL`, or `<url>/auth/v1/.well-known/jwks.json`. */
-  readonly jwksUrl: URL;
-  /** `SUPABASE_JWKS`: inline keys, used instead of fetching `jwksUrl`. */
-  readonly jwks?: InlineJwks;
-  /**
-   * Postgres connection string: `SUPABASE_DB_URL`, `DATABASE_URL`, then
-   * the Vercel integration's `POSTGRES_URL` (pooled) and
-   * `POSTGRES_URL_NON_POOLING`.
-   */
-  readonly dbUrl?: string;
-  /** Project ref for hosted projects (`<ref>.supabase.co`). */
-  readonly projectRef?: string;
-  /** `SUPABASE_READ_URL`: a read replica or the `<ref>-all` load balancer, for reads. */
-  readonly readUrl?: string;
-  /**
-   * `SUPABASE_JWT_SECRET`: the shared HS256 secret Supabase Lite signs user
-   * tokens with (`auth.jwt_secret`). Server-only; read with `backend: "lite"`.
-   */
-  readonly jwtSecret?: string;
-}
-/** A JSON Web Key Set, as `@supabase/server` verifies with it. */
-type InlineJwks = Exclude<SupabaseEnv["jwks"], URL | null>;
-interface PublicEnv {
-  readonly url: string;
-  readonly publishableKey: string;
-}
-type EnvSource = Readonly<Record<string, string | undefined>>;
-interface EnvIssue {
-  /** The variable names that were checked, first one preferred. */
-  readonly variables: readonly string[];
-  readonly message: string;
-}
-interface EnvOptions {
-  /** Settings that must be present. `url` and `publishableKey` always are. */
-  readonly require?: readonly ("secretKey" | "dbUrl")[];
-}
-type EnvResult = {
-  readonly ok: true;
-  readonly env: BetterSupabaseEnv;
-  readonly issues?: undefined;
-} | {
-  readonly ok: false;
-  readonly env?: undefined;
-  readonly issues: readonly EnvIssue[];
-};
-declare const ENV_VARIABLES: {
-  readonly url: readonly string[];
-  readonly publishableKey: readonly string[];
-  readonly secretKey: readonly string[];
-  readonly dbUrl: readonly string[];
-  readonly jwksUrl: readonly string[];
-  readonly jwks: readonly string[];
-  readonly readUrl: readonly string[];
-  readonly jwtSecret: readonly string[];
-};
-declare class EnvValidationError extends Error {
-  override readonly name = "EnvValidationError";
-  readonly issues: readonly EnvIssue[];
-  constructor(issues: readonly EnvIssue[]);
-}
-/**
- * Reads and validates Supabase settings. Accepts the `SUPABASE_`,
- * `NEXT_PUBLIC_`, `VITE_`, `PUBLIC_`, `EXPO_PUBLIC_` and `NUXT_PUBLIC_`
- * spellings. Issues name variables, never values.
- */
-declare function parseEnv(source: EnvSource, options?: EnvOptions): EnvResult;
-/** Like `parseEnv`, but throws `EnvValidationError`. Reads `process.env` by default. */
-declare function loadEnv(source?: EnvSource, options?: EnvOptions): BetterSupabaseEnv;
-/** The env validator as a Standard Schema, for t3-env, framework config or any validator slot. */
-declare function envSchema(options?: EnvOptions): StandardSchemaV1<EnvSource, BetterSupabaseEnv>;
-/** The parts that are safe in client bundles. */
-declare function publicEnv(env: BetterSupabaseEnv): PublicEnv;
-/** Converts to `@supabase/server`'s `SupabaseEnv` (the `env` option of `withSupabase`). */
-declare function toServerEnv(env: BetterSupabaseEnv): SupabaseEnv;
-//#endregion
-export { EnvResult as a, InlineJwks as c, loadEnv as d, parseEnv as f, EnvOptions as i, PublicEnv as l, toServerEnv as m, ENV_VARIABLES as n, EnvSource as o, publicEnv as p, EnvIssue as r, EnvValidationError as s, BetterSupabaseEnv as t, envSchema as u };

package/dist/index-DTQSeHx2.d.ts

@@ -1,97 +0,0 @@
-import { b as DbError, f as Result } from "./result-BREt7qOh.js";
-import { F as SchemaMeta } from "./types-BrpW5ixT.js";
-import { at as QuerySpec } from "./define-DYZnvAbs.js";
-import { c as RealtimeClient, p as SubscriptionStatus } from "./topic-DAY_HOX2.js";
-//#region src/realtime/live.d.ts
-/** What `liveQuery` needs from `betterSupabase`: metadata and the tables a spec reads. */
-interface LiveSource {
-  readonly meta: SchemaMeta;
-  tablesOf(spec: QuerySpec): string[];
-}
-interface LiveQueryOptions {
-  /** Called once per burst of changes, with the app keys of the tables that changed. */
-  readonly onChange: (tables: readonly string[]) => void;
-  /** Tenant value for tables scoped by a tenant column (`realtime-tables` topics). */
-  readonly tenant?: string;
-  /** The signed-in user's id, for tables that broadcast per user (`realtime.users`). */
-  readonly user?: string;
-  /** Waits this long after the last change before calling `onChange`. Defaults to 100 ms. */
-  readonly debounceMs?: number;
-  /**
-   * Also reports a channel that errors after it joined (`error`) and its
-   * rejoin (`subscribed`), not only the first join.
-   */
-  readonly onStatus?: (status: SubscriptionStatus, error?: Error) => void;
-  /**
-   * Retries a first join that failed, after 1 s and then twice as long each
-   * time, up to 30 s. Pass `false` to stay in `error`. Defaults to `true`.
-   */
-  readonly retry?: boolean;
-}
-interface LiveSubscription extends Disposable, AsyncDisposable {
-  /** App keys of the watched tables. */
-  readonly tables: readonly string[];
-  /** Tables the query reads that don't broadcast changes (not in `realtime.tables`). */
-  readonly unwatched: readonly string[];
-  readonly ready: Promise<void>;
-  unsubscribe(): Promise<void>;
-}
-/**
- * A count from the server plus the spec to keep it live on the client:
- * `bs.liveCount(spec)` makes one, `useLiveCount(seed)` reads it. `count`
- * is `null` when the server read failed; the client then fetches it.
- */
-interface LiveCountSeed<T extends string = string> {
-  readonly spec: QuerySpec<T, "count", number>;
-  readonly count: number | null;
-  /** When the count was taken (epoch ms). `useLiveCount` counts again after joining when it is older than a second. */
-  readonly at?: number;
-}
-/**
- * Topic a `realtime-tables` trigger broadcasts on:
- * `bs:t:<schema>.<table>[:<tenant>]`, or `bs:t:<schema>.<table>:u:<user>`
- * for a `realtime.users` table.
- */
-declare function liveTopic(meta: SchemaMeta, table: string, tenant?: string, user?: string): string;
-/**
- * Calls `onChange` when a table the spec reads changes, so you can refetch.
- * Needs the `realtime-tables` SQL module and the tables in
- * `realtime.tables`. Live queries on the same client share one channel per
- * table, so any number of them can run at once.
- *
- * ```ts
- * using live = liveQuery(betterSupabase, supabase, spec, { onChange: () => refetch() });
- * ```
- */
-declare function liveQuery(betterSupabase: LiveSource, client: RealtimeClient, spec: QuerySpec | readonly string[], options: LiveQueryOptions): LiveSubscription;
-/** What `liveCount` runs the spec with: a `db` from `betterSupabase.connect()` or `createClient()`. */
-interface CountRunner {
-  $run(spec: QuerySpec): PromiseLike<Result<unknown>>;
-}
-interface LiveCountOptions extends Omit<LiveQueryOptions, "onChange"> {
-  readonly onCount: (count: number) => void;
-  /** A failed refetch; the previous count stays valid. */
-  readonly onError?: (error: DbError) => void;
-  /** Count right away. Defaults to `true`; pass `false` when you have a seed. */
-  readonly immediate?: boolean;
-  /**
-   * When the count you already have was taken (epoch ms). Counts again once
-   * the channel joins when that is more than a second ago, so a change made
-   * before the join is not lost.
-   */
-  readonly since?: number;
-}
-/**
- * Keeps a count current: runs the `count` spec (a HEAD request) now, after
- * each debounced change to a table it reads, and after the channel rejoins.
- * Responses that arrive out of order are dropped.
- *
- * ```ts
- * using live = liveCount(betterSupabase, supabase, db, betterSupabase.spec.notes.count(), {
- *   onCount: (count) => render(count),
- * });
- * ```
- */
-declare function liveCount(betterSupabase: LiveSource, client: RealtimeClient, db: CountRunner, spec: QuerySpec<string, "count", number>, options: LiveCountOptions): LiveSubscription;
-//#endregion
-export { LiveSource as a, liveQuery as c, LiveQueryOptions as i, liveTopic as l, LiveCountOptions as n, LiveSubscription as o, LiveCountSeed as r, liveCount as s, CountRunner as t };

package/dist/index-Hc4tetmB.d.ts

@@ -1,245 +0,0 @@
-import { b as DbError, f as Result, t as AsyncResult } from "./result-BREt7qOh.js";
-import { N as StorageClient, Q as StoragePath, a as BucketConnectOptions, h as StorageAdminClient, i as BucketConfig, n as Bucket, r as BucketClient, s as BucketPolicy } from "./bucket-BbePDVwc.js";
-import { SupabaseClient } from "@supabase/supabase-js";
-//#region src/storage/errors.d.ts
-/** Maps a Storage error (`StorageApiError`, fetch failures) to a `DbError`. */
-declare function fromStorageError(raw: unknown, table?: string): DbError;
-//#endregion
-//#region src/storage/image-url.d.ts
-interface StorageImageOptions {
-  /** Project URL, e.g. `import.meta.env.PUBLIC_SUPABASE_URL`. */
-  readonly url: string;
-  /** Resize mode for the transform. Defaults to Storage's own (`cover`). */
-  readonly resize?: "cover" | "contain" | "fill";
-}
-/** The size and quality to render an image at. */
-interface StorageImageSize {
-  readonly width: number;
-  readonly height?: number | undefined;
-  readonly quality?: number | undefined;
-}
-/**
- * Turns public Storage object URLs into Supabase image transformation URLs
- * (`/render/image/public`) at a given size. Any other URL (local files,
- * other hosts, signed URLs) comes back as `undefined`: a signed URL's token
- * covers the transform it was signed with, so sign it with `renderUrl()`.
- *
- * ```ts
- * const imageUrl = storageImageUrl({ url: SUPABASE_URL })
- * imageUrl(avatar, { width: 96 }) ?? avatar
- * ```
- */
-declare function storageImageUrl(options: StorageImageOptions): (src: string, size: StorageImageSize) => string | undefined;
-//#endregion
-//#region src/storage/registry.d.ts
-/** Any bucket definition from `defineBucket` or a preset. */
-type AnyBucket = Bucket<string>;
-type BucketMap = Readonly<Record<string, AnyBucket>>;
-/** The bucket ids of a registry's buckets. */
-type BucketIdOf<B extends BucketMap> = B[keyof B]["id"];
-/** The bucket of a registry whose id is `I`. */
-type BucketWithId<B extends BucketMap, I extends string> = Extract<B[keyof B], {
-  readonly id: I;
-}>;
-/** A stored object as rows keep it: the bucket id and the object path. */
-interface StoredRef {
-  /** The bucket id, e.g. a `bucket_id` column. */
-  readonly bucket: string;
-  readonly path: string;
-}
-/** A stored reference whose bucket is registered and whose path matches one of its templates. */
-interface ResolvedRef<B extends BucketMap> {
-  readonly bucket: B[keyof B];
-  readonly path: StoragePath<BucketIdOf<B>>;
-}
-/** A resolved reference with a client of its bucket. */
-interface ConnectedRef<B extends BucketMap> extends ResolvedRef<B> {
-  readonly storage: BucketClient<string, BucketIdOf<B>>;
-}
-interface Buckets<B extends BucketMap> {
-  /** The bucket definitions, by the names given. */
-  readonly buckets: B;
-  /** Every registered bucket id, in the order given. */
-  readonly ids: readonly BucketIdOf<B>[];
-  /** Whether `id` names a registered bucket. */
-  has(id: string): id is BucketIdOf<B>;
-  /** The bucket with this id, or `invalid_input` for an id no bucket has. */
-  byId<I extends BucketIdOf<B>>(id: I): Result<BucketWithId<B, I>>;
-  byId(id: string): Result<B[keyof B]>;
-  /**
-   * Checks a stored `{ bucket, path }`: the bucket must be registered and the
-   * path must match one of its templates. Either failure is `invalid_input`.
-   */
-  resolve(ref: StoredRef): Result<ResolvedRef<B>>;
-  /**
-   * `resolve`, then `connect` the bucket and check the path with the
-   * connected client, so a bucket with `tenant` also refuses another
-   * tenant's path (`forbidden`). No request is made.
-   */
-  connectStored(client: StorageClient, ref: StoredRef, options?: BucketConnectOptions): Result<ConnectedRef<B>>;
-}
-/**
- * A registry of bucket definitions by id, for rows that store a bucket id
- * next to an object path (files, attachments, sources). An id no bucket
- * has, and a path outside the bucket's templates, are errors, never a
- * fallback bucket.
- *
- * ```ts
- * export const buckets = defineBuckets({ files, attachments, logos });
- *
- * const ref = buckets.connectStored(supabase, {
- *   bucket: row.bucketId,
- *   path: row.path,
- * }, { context: db.$context });
- * if (ref.ok) await ref.data.storage.signedUrl(ref.data.path);
- * ```
- */
-declare function defineBuckets<const B extends BucketMap>(buckets: B): Buckets<B>;
-//#endregion
-//#region src/storage/presets.d.ts
-/** The image types browsers display everywhere. */
-declare const IMAGE_TYPES: readonly string[];
-interface ImageBucketOptions<P extends string, Id extends string> {
-  readonly id?: Id;
-  /** The path template; keep the preset's placeholders the policy relies on. */
-  readonly path?: P | readonly [P, ...P[]];
-  /** Defaults to `true`: images load from their public URL without signing. */
-  readonly public?: boolean;
-  readonly fileSizeLimit?: string | number;
-  readonly allowedMimeTypes?: readonly string[];
-  /** Replaces the preset's policy. */
-  readonly policy?: BucketPolicy;
-}
-type AvatarBucketOptions<P extends string, Id extends string> = ImageBucketOptions<P, Id>;
-interface OrganizationLogoBucketOptions<P extends string, Id extends string> extends ImageBucketOptions<P, Id> {
-  /**
-   * The permission that may upload, replace and delete a logo, checked
-   * through the access contract. Defaults to `organization.update`, the
-   * `organizations` module's update permission.
-   */
-  readonly permission?: string;
-  /**
-   * The tenant segment connected clients are held to. `false` lets one
-   * client upload for any organization the policy allows. Defaults to
-   * `{ param: 'organizationId' }`.
-   */
-  readonly tenant?: BucketConfig["tenant"] | false;
-}
-declare const AVATAR_PATH = "{userId}/avatar-{version}.{ext}";
-declare const LOGO_PATH = "{organizationId}/logo-{version}.{ext}";
-/**
- * A bucket for profile pictures: `{userId}/avatar-{version}.{ext}`, public,
- * 2 MiB of images, written only by their owner (the `owner` policy).
- */
-declare function avatarBucket<const P extends string = typeof AVATAR_PATH, const Id extends string = "avatars">(options?: AvatarBucketOptions<P, Id>): Bucket<P, Id>;
-/**
- * A bucket for organization logos: `{organizationId}/logo-{version}.{ext}`, public,
- * 2 MiB of images, written by members with the update permission through
- * the access contract (`tenant_ids_with`), so it follows the app's roles.
- */
-declare function organizationLogoBucket<const P extends string = typeof LOGO_PATH, const Id extends string = "organization-logos">(options?: OrganizationLogoBucketOptions<P, Id>): Bucket<P, Id>;
-//#endregion
-//#region src/storage/analytics-bucket.d.ts
-/** The Iceberg REST catalog of an analytics bucket, from `storage.analytics.from(id)`. */
-type AnalyticsCatalog = ReturnType<SupabaseClient["storage"]["analytics"]["from"]>;
-interface AnalyticsBucketClient {
-  /** Creates the bucket when it is missing. Needs the secret key. */
-  apply(): AsyncResult<{
-    readonly created: boolean;
-  }>;
-  /** The bucket's Iceberg catalog: namespaces and tables, each call returning `{ data, error }`. */
-  catalog(): AnalyticsCatalog;
-}
-interface AnalyticsBucket<Id extends string> {
-  readonly id: Id;
-  connect(client: StorageAdminClient): AnalyticsBucketClient;
-}
-/**
- * A Storage analytics bucket: Apache Iceberg tables that query engines read
- * through the Iceberg REST catalog.
- *
- * ```ts
- * export const events = defineAnalyticsBucket({ id: "events" });
- * await events.connect(admin).apply().orThrow();
- * ```
- */
-declare function defineAnalyticsBucket<const Id extends string>(config: {
-  readonly id: Id;
-}): AnalyticsBucket<Id>;
-//#endregion
-//#region src/storage/vector-bucket.d.ts
-type VectorDistance = "cosine" | "euclidean" | "dotproduct";
-interface VectorIndexConfig {
-  /** Number of values in every vector, e.g. 1536 for `text-embedding-3-small`. */
-  readonly dimension: number;
-  /** Defaults to `cosine`. */
-  readonly distanceMetric?: VectorDistance;
-  /** Metadata keys stored with each vector but not usable in `filter`. */
-  readonly nonFilterableMetadataKeys?: readonly string[];
-}
-interface VectorBucketConfig<Id extends string, I extends Readonly<Record<string, VectorIndexConfig>>> {
-  readonly id: Id;
-  readonly indexes: I;
-}
-type VectorMetadata = Readonly<Record<string, unknown>>;
-interface VectorRecord<M extends VectorMetadata = VectorMetadata> {
-  readonly key: string;
-  readonly vector: readonly number[];
-  readonly metadata?: M;
-}
-interface VectorHit<M extends VectorMetadata = VectorMetadata> {
-  readonly key: string;
-  /** Set by `query()`: smaller is closer for every metric. */
-  readonly distance?: number;
-  readonly metadata?: M;
-  readonly vector?: readonly number[];
-}
-interface VectorQueryOptions {
-  /** Number of matches, defaults to 10. */
-  readonly topK?: number;
-  /** A metadata filter, e.g. `{ organizationId: "o1" }` or `{ year: { $gte: 2024 } }`. */
-  readonly filter?: VectorMetadata;
-  /** Return each match's metadata. Defaults to `true`. */
-  readonly metadata?: boolean;
-}
-interface VectorIndexClient<M extends VectorMetadata = VectorMetadata> {
-  readonly name: string;
-  readonly dimension: number;
-  /** Inserts or replaces vectors by key, in batches of 500. */
-  put(records: readonly VectorRecord<M>[]): AsyncResult<number>;
-  /** The nearest vectors, closest first. */
-  query(vector: readonly number[], options?: VectorQueryOptions): AsyncResult<readonly VectorHit<M>[]>;
-  /** Vectors by key; missing keys are left out. */
-  get(keys: readonly string[], options?: {
-    readonly vector?: boolean;
-  }): AsyncResult<readonly VectorHit<M>[]>;
-  remove(keys: readonly string[]): AsyncResult<readonly string[]>;
-}
-interface VectorBucketClient<I extends string> {
-  /** Creates the bucket and any missing index. An index with another dimension or metric is a `conflict`. */
-  apply(): AsyncResult<{
-    readonly created: readonly string[];
-  }>;
-  index<M extends VectorMetadata = VectorMetadata>(name: I): VectorIndexClient<M>;
-}
-interface VectorBucket<Id extends string, I extends Readonly<Record<string, VectorIndexConfig>>> {
-  readonly id: Id;
-  readonly indexes: I;
-  connect(client: StorageAdminClient): VectorBucketClient<keyof I & string>;
-}
-/**
- * A Storage vector bucket with typed indexes. Storage keeps the vectors
- * outside Postgres; use the `vector-search` module for pgvector in a table.
- *
- * ```ts
- * export const embeddings = defineVectorBucket({
- *   id: "embeddings",
- *   indexes: { documents: { dimension: 1536 } },
- * });
- * const docs = embeddings.connect(admin).index("documents");
- * await docs.put([{ key: doc.id, vector, metadata: { organizationId } }]);
- * ```
- */
-declare function defineVectorBucket<const Id extends string, const I extends Readonly<Record<string, VectorIndexConfig>>>(config: VectorBucketConfig<Id, I>): VectorBucket<Id, I>;
-//#endregion
-export { defineBuckets as A, BucketIdOf as C, ConnectedRef as D, Buckets as E, StorageImageSize as M, storageImageUrl as N, ResolvedRef as O, fromStorageError as P, AnyBucket as S, BucketWithId as T, IMAGE_TYPES as _, VectorHit as a, avatarBucket as b, VectorMetadata as c, defineVectorBucket as d, AnalyticsBucket as f, AvatarBucketOptions as g, defineAnalyticsBucket as h, VectorDistance as i, StorageImageOptions as j, StoredRef as k, VectorQueryOptions as l, AnalyticsCatalog as m, VectorBucketClient as n, VectorIndexClient as o, AnalyticsBucketClient as p, VectorBucketConfig as r, VectorIndexConfig as s, VectorBucket as t, VectorRecord as u, ImageBucketOptions as v, BucketMap as w, organizationLogoBucket as x, OrganizationLogoBucketOptions as y };

package/dist/index-QWTq2o31.d.ts

@@ -1,138 +0,0 @@
-import { n as RouteGuardOptions } from "./refusal-C7geIBRl.js";
-import { t as Validated } from "./shared-DDSjEGDR.js";
-import { AnyEntry, Contributions } from "@supabase/middleware";
-import { IncomingMessage, ServerResponse } from "node:http";
-//#region src/node/http.d.ts
-interface WebRequestOptions {
-  /**
-   * Read the protocol and host from `x-forwarded-proto` and
-   * `x-forwarded-host`. Turn it on behind a proxy you control. Defaults to false.
-   */
-  readonly trustProxy?: boolean;
-  /** Stream the request body into the `Request`. Defaults to true. */
-  readonly body?: boolean;
-}
-/**
- * A Node `IncomingMessage` as a Web `Request`. Express, Fastify and Koa
- * pass theirs (`req`, `request.raw`, `ctx.req`). With `body: false` the
- * stream stays unread, for middleware that runs before a body parser.
- */
-declare function toWebRequest(req: IncomingMessage, options?: WebRequestOptions): Request;
-/** Writes a Web `Response` to a Node `ServerResponse`, streaming the body. */
-declare function sendWebResponse(res: ServerResponse, response: Response): Promise<void>;
-//#endregion
-//#region src/node/index.d.ts
-interface ToNodeOptions<Req = IncomingMessage> extends Omit<WebRequestOptions, "body"> {
-  /** The host's env object for `getEnv`; defaults to `process.env` through `getEnv`. */
-  readonly env?: (req: Req) => unknown;
-}
-/**
- * A `node:http` request listener running the entries around `handler`.
- * Response-phase entries see the handler's response, so refreshed cookies
- * and `withDbStats` totals reach the client.
- *
- * ```ts
- * createServer(toNodeHandler([withBetterSupabase(server)], (request, { db }) => db.notes.findMany()))
- * ```
- */
-declare function toNodeHandler<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, handler: (request: Request, contributions: Contributions<Entries>) => unknown, options?: ToNodeOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-/** The part of an Express response the middleware writes. */
-interface ExpressResponse extends ServerResponse {
-  /** Express's per-request locals; the contributions land here. */
-  locals: Record<string, unknown>;
-}
-/** Express (or Connect) middleware, typed structurally. */
-type ExpressMiddleware = (req: IncomingMessage, res: ExpressResponse, next: (error?: unknown) => void) => void;
-/** An Express error handler, typed structurally. */
-type ExpressErrorHandler = (error: unknown, req: IncomingMessage, res: ExpressResponse, next: (error?: unknown) => void) => void;
-/**
- * Express middleware that puts every contribution on `res.locals`
- * (`res.locals.db`, `res.locals.bs`). Mount it before the routes.
- *
- * ```ts
- * app.use(toExpress([withBetterSupabase(server)]))
- * app.get('/notes', async (req, res) => res.json(await res.locals.db.notes.findMany().orThrow()))
- * ```
- */
-declare function toExpress<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToNodeOptions): ExpressMiddleware;
-/**
- * Express route middleware that refuses callers outside `options`:
- * Problem Details, or a redirect to `signIn` or `mfa`. Runs after `toExpress`.
- *
- * ```ts
- * app.get('/admin', guard({ roles: ['admin'] }), handler)
- * ```
- */
-declare function guard(options?: RouteGuardOptions): ExpressMiddleware;
-/**
- * An Express error handler that answers thrown `DbException`s (from
- * `.orThrow()`) with Problem Details and passes every other error on.
- * Register it after the routes.
- */
-declare function problemErrorHandler(options?: {
-  readonly expose?: boolean;
-}): ExpressErrorHandler;
-/** The part of a Fastify request the hook reads and writes. */
-interface FastifyRequestLike {
-  readonly raw: IncomingMessage;
-  /** The contributions land here: `request.locals.db`. */
-  locals?: Record<string, unknown>;
-}
-/** The part of a Fastify reply the hook writes. */
-interface FastifyReplyLike {
-  readonly raw: ServerResponse;
-  readonly sent: boolean;
-  code(status: number): FastifyReplyLike;
-  header(name: string, value: string | readonly string[]): FastifyReplyLike;
-  getHeader(name: string): number | string | string[] | undefined;
-  send(payload?: unknown): FastifyReplyLike;
-}
-/** A Fastify `onRequest` or `preHandler` hook, typed structurally. */
-type FastifyHook = (request: FastifyRequestLike, reply: FastifyReplyLike) => Promise<void>;
-/**
- * A Fastify `onRequest` hook that puts every contribution on
- * `request.locals`. Declare `locals` with `app.decorateRequest('locals', null)`.
- *
- * ```ts
- * app.decorateRequest('locals', null)
- * app.addHook('onRequest', toFastify([withBetterSupabase(server)]))
- * app.get('/notes', (request) => request.locals.db.notes.findMany().orThrow())
- * ```
- */
-declare function toFastify<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToNodeOptions<FastifyRequestLike>): FastifyHook;
-/**
- * A Fastify `preHandler` hook that refuses callers outside `options`. Runs
- * after `toFastify`.
- */
-declare function fastifyGuard(options?: RouteGuardOptions): FastifyHook;
-/** The part of a Koa context the middleware reads and writes. */
-interface KoaContextLike {
-  readonly req: IncomingMessage;
-  readonly res: ServerResponse;
-  /** Koa's per-request state; the contributions land here. */
-  state: Record<string, unknown>;
-  status: number;
-  body: unknown;
-  set(name: string, value: string | readonly string[]): void;
-  get response(): {
-    get(name: string): string | string[] | undefined;
-  };
-}
-/** Koa middleware, typed structurally. */
-type KoaMiddleware = (ctx: KoaContextLike, next: () => Promise<unknown>) => Promise<void>;
-/**
- * Koa middleware that puts every contribution on `ctx.state`, then awaits
- * the rest of the chain. Thrown `DbException`s become Problem Details.
- *
- * ```ts
- * app.use(toKoa([withBetterSupabase(server)]))
- * app.use(async (ctx) => { ctx.body = await ctx.state.db.notes.findMany().orThrow() })
- * ```
- */
-declare function toKoa<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToNodeOptions<KoaContextLike> & {
-  readonly expose?: boolean;
-}): KoaMiddleware;
-/** Koa middleware that refuses callers outside `options`. Runs after `toKoa`. */
-declare function koaGuard(options?: RouteGuardOptions): KoaMiddleware;
-//#endregion
-export { toNodeHandler as _, FastifyReplyLike as a, toWebRequest as b, KoaMiddleware as c, guard as d, koaGuard as f, toKoa as g, toFastify as h, FastifyHook as i, ToNodeOptions as l, toExpress as m, ExpressMiddleware as n, FastifyRequestLike as o, problemErrorHandler as p, ExpressResponse as r, KoaContextLike as s, ExpressErrorHandler as t, fastifyGuard as u, WebRequestOptions as v, sendWebResponse as y };