better-supabase 0.13.0 → 0.14.0

package/dist/session-DNRYXIOU.d.ts

@@ -1,97 +0,0 @@
-import { a as AnyModels, i as AnyFunctions } from "./types-DmshMaXz.js";
-import { n as AuthOutageEvent, o as EventHub } from "./events-DhGgwqQA.js";
-import { f as CookieScope, h as SessionEncoding, r as AuthState, t as AuthResolution } from "./resolve-D57oDWNr.js";
-import { a as ServerContext, r as ContextOptions, v as ActiveSupport } from "./server-types-D_cQ6OxZ.js";
-import { d as RefreshPolicy } from "./respond-QW-f1yio.js";
-import { SingleKeyEntry } from "@supabase/middleware";
-//#region src/server/entries/core.d.ts
-/**
- * What the entries need from a `createServer` server: its resolver, its
- * request-scoped context builder and the settings behind them. The server
- * registers it once; entries read it with `serverCore(server)`.
- */
-interface ServerCore<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> {
-  readonly events: EventHub;
-  /** How long reads stay on the primary after a write. */
-  readonly pinMs: number;
-  resolve(request: Request, options: {
-    readonly refresh?: boolean;
-    readonly cookies?: boolean;
-    readonly encode?: SessionEncoding;
-    readonly checkSession?: boolean;
-  }): Promise<AuthResolution<C, P>>;
-  /** The session cookie's name (`auth.cookie.name`, else `sb-<ref>-auth-token`). */
-  sessionCookie(): string;
-  /** `ServerOptions.tenant`, or `undefined` without one. */
-  tenant(request: Request, auth: AuthState<C, P>): string | undefined | PromiseLike<string | undefined>;
-  support(request: Request, auth: AuthState<C, P>): Promise<ActiveSupport | undefined>;
-  context(resolution: AuthResolution<C, P>, request: Request, options: ContextOptions, tenant: string | undefined): ServerContext<M, F, E, C, P, B>;
-}
-/** The core of a server built by `createServer` or one of the adapter factories. */
-declare function serverCore<M extends AnyModels, F extends AnyFunctions, E, C, P, B>(server: {
-  readonly events: EventHub;
-  context(request: Request): Promise<ServerContext<M, F, E, C, P, B>>;
-}): ServerCore<M, F, E, C, P, B>;
-//#endregion
-//#region src/server/entries/session.d.ts
-interface SessionEntryConfig {
-  /**
-   * Refresh an expired cookie session and send the new cookies on the response.
-   * Only where cookies can be written once per request (a proxy, a framework
-   * middleware); never in Server Components. `'navigation'` refreshes page
-   * loads, navigations and form posts (`shouldRefresh`), so parallel `fetch`
-   * calls never race on the refresh token. Defaults to false.
-   */
-  readonly refresh?: RefreshPolicy;
-  /**
-   * Ask the Auth server whether the session still exists, so a session ended
-   * elsewhere (sign-out on another device, an admin revoke) is anon here too.
-   * One Auth call per matching request: `true` checks every request,
-   * `'navigation'` full page loads (`shouldCheckSession`). Off by default,
-   * because a valid token otherwise never calls the Auth server.
-   */
-  readonly checkSession?: boolean | "navigation" | ((request: Request) => boolean);
-  /**
-   * Read the session cookie. Defaults to true; `false` resolves bearer tokens
-   * only.
-   */
-  readonly cookies?: boolean;
-  /**
-   * Keeps the invocation alive for event sink sends the handler started:
-   * `EdgeRuntime.waitUntil`, the Workers `ctx.waitUntil` or Next's `after`.
-   */
-  readonly waitUntil?: (promise: Promise<unknown>) => void;
-  /**
-   * The shape refreshed sessions are written in, `cookies.encode` in
-   * `@supabase/ssr`. Use the browser client's value. Defaults to the server's
-   * `auth.cookie.encode`, then `user-and-tokens`.
-   */
-  readonly encode?: SessionEncoding;
-  /**
-   * Cookie scopes (`domain`, `path`) earlier deploys wrote the session at. Each
-   * response to a request that carries the session cookie expires it at these
-   * scopes, like `clearAuthCookiesAtScopes` in `@supabase/ssr`, so moving the
-   * cookie to a new domain or path is one config change. Never list the current
-   * scope: that clears the live session.
-   */
-  readonly cookieScopes?: readonly CookieScope[];
-  /**
-   * Called when a refresh failed because the Auth server was unreachable, timed
-   * out or answered 5xx or 429. When the access token couldn't be kept
-   * (`event.kept` is false), a returned `Response` answers the request instead
-   * of the handler, such as a 503 with `Retry-After`. A throw is logged and
-   * ignored.
-   */
-  readonly onAuthOutage?: AuthOutageHook;
-}
-/** `onAuthOutage` on the session entry and the Next.js proxy. */
-type AuthOutageHook = (event: AuthOutageEvent, request: Request) => Response | undefined | void | Promise<Response | undefined | void>;
-/**
- * Entry contributing `ctx.session`, the request's `AuthResolution`: a bearer
- * token first, the session cookie second. It is the only entry with a response
- * seam for cookies: on the way out it adds the refreshed session cookies and
- * the no-store headers, and hands pending event sends to `waitUntil`.
- */
-declare function withSession<M extends AnyModels, F extends AnyFunctions, E, C, P, B>(core: ServerCore<M, F, E, C, P, B>, config?: SessionEntryConfig): SingleKeyEntry<"session", Record<never, never>, AuthResolution<C, P>>;
-//#endregion
-export { serverCore as a, ServerCore as i, SessionEntryConfig as n, withSession as r, AuthOutageHook as t };

package/dist/settings-DzQtMwfl.js

@@ -1,93 +0,0 @@
-import { n as dbError } from "./errors-D7u24ZJH.js";
-import { r as err, t as AsyncResult } from "./result-DIT_qp4G.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { n as validate } from "./standard-l10kE0yS.js";
-import { n as applyTemporal, o as blockCall } from "./block-helpers-DwE32_gT.js";
-import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
-//#region src/blocks/settings/settings.ts
-/**
-* Declares the app's settings with a Standard Schema per key. Values are
-* validated before they are written, and stored values that no longer match
-* their schema read as the default. Pass the result to `createSettings`.
-*/
-function defineSettings(spec) {
-	return { schemas: {
-		user: spec.user ?? {},
-		organization: spec.organization ?? {},
-		platform: spec.platform ?? {}
-	} };
-}
-/**
-* The settings block: typed `get`, `set` and `reset` over the settings module's
-* functions.
-*/
-function createSettings(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const { user, organization, platform } = (options.settings ?? defineSettings({})).schemas;
-	function getUser(key) {
-		return reader(user, call, "get_user_settings", {}, key);
-	}
-	function getOrganization(organizationId, key) {
-		return reader(organization, call, "get_organization_settings", { tenant: organizationId }, key);
-	}
-	function getPlatform(key) {
-		return reader(platform, call, "get_platform_settings", {}, key);
-	}
-	return withBlockHooks({
-		getUser,
-		setUser: (key, value) => writer(user, call, "set_user_setting", {}, key, value),
-		resetUser: (key) => remover(user, call, "reset_user_setting", {}, key),
-		getOrganization,
-		setOrganization: (organizationId, key, value) => writer(organization, call, "set_organization_setting", { tenant: organizationId }, key, value),
-		resetOrganization: (organizationId, key) => remover(organization, call, "reset_organization_setting", { tenant: organizationId }, key),
-		getPlatform,
-		setPlatform: (key, value) => writer(platform, call, "set_platform_setting", {}, key, value),
-		resetPlatform: (key) => remover(platform, call, "reset_platform_setting", {}, key)
-	}, options.hooks, {
-		block: "settings",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-/** Stored values merged over the defaults; unknown keys are dropped. */
-async function merged(entries, stored) {
-	const values = isRecord(stored) ? stored : {};
-	const out = {};
-	for (const [key, entry] of Object.entries(entries)) out[key] = await readValue(entry, values[key]);
-	return out;
-}
-async function readValue(entry, stored) {
-	if (stored === void 0) return entry.default;
-	const parsed = await validate(entry.schema, stored);
-	return parsed.ok ? parsed.data : entry.default;
-}
-function unknownSetting(key) {
-	return AsyncResult.from(() => Promise.resolve(err(dbError("invalid_input", `Unknown setting "${key}"`))));
-}
-/** Reads every key, or one key, through `fn`. */
-function reader(entries, call, fn, args, key) {
-	if (key !== void 0 && !(key in entries)) return unknownSetting(key);
-	return call(fn, args, async (stored) => {
-		const values = await merged(entries, stored);
-		return key === void 0 ? values : values[key];
-	});
-}
-/** Validates `value` with the key's schema, then writes the output through `fn`. */
-function writer(entries, call, fn, args, key, value) {
-	const entry = entries[key];
-	if (!entry) return unknownSetting(key);
-	return AsyncResult.from(() => validate(entry.schema, value, `setting "${key}"`)).andThen((output) => call(fn, {
-		...args,
-		key,
-		value: { value: output ?? null }
-	}, () => output));
-}
-function remover(entries, call, fn, args, key) {
-	if (!(key in entries)) return unknownSetting(key);
-	return call(fn, {
-		...args,
-		key
-	}, (removed) => removed === true);
-}
-//#endregion
-export { defineSettings as n, createSettings as t };

package/dist/shared-C80IHf4B.js

@@ -1,60 +0,0 @@
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError } from "./errors-D7u24ZJH.js";
-//#region src/plugins/shared.ts
-/** Database column name for an app column, or `undefined` if it is unknown. */
-function dbName(table, app) {
-	return app === void 0 ? void 0 : table.columns[app]?.db;
-}
-function isNull(column) {
-	return {
-		kind: "column",
-		column,
-		op: "is",
-		value: null
-	};
-}
-function isNotNull(column) {
-	return {
-		kind: "not",
-		item: isNull(column)
-	};
-}
-function equals(column, value) {
-	return {
-		kind: "column",
-		column,
-		op: "eq",
-		value
-	};
-}
-/** Sets `column` on a row unless the caller already provided it. */
-function withDefault(row, column, value) {
-	if (column === void 0 || column in row) return row;
-	return {
-		...row,
-		[column]: value
-	};
-}
-/**
-* Refuses caller-supplied values for columns a plugin fills (timestamps, actor,
-* soft delete) unless the call passes `{ override: true }`. Returns whether the
-* caller may keep its own values.
-*/
-function guardManaged(op, columns, plugin, options) {
-	if (options["override"] === true) return true;
-	const rows = op.kind === "insert" ? op.rows : op.kind === "update" ? [op.set] : [];
-	for (const column of columns) {
-		if (column === void 0) continue;
-		if (rows.some((row) => column in row)) throw new DbException(dbError("invalid_request", `"${column}" on ${op.table.key} is filled by ${plugin}(); pass { override: true } to set it yourself`, { table: op.table.key }));
-	}
-	return false;
-}
-/** Upserts that may update existing rows must not overwrite "created" columns. */
-function insertsOnly(op) {
-	return !op.onConflict || op.onConflict.action === "ignore";
-}
-function forbidden(message) {
-	throw new DbException(dbError("forbidden", message));
-}
-//#endregion
-export { insertsOnly as a, withDefault as c, guardManaged as i, equals as n, isNotNull as o, forbidden as r, isNull as s, dbName as t };

package/dist/shared-D11SWNLx.js

@@ -1,17 +0,0 @@
-import { n as invalidRequest } from "./build-UqJeGtsH.js";
-//#region src/compile/shared.ts
-/** A row-count or offset value that is safe to inline into SQL text. */
-function integer(value) {
-	if (!Number.isInteger(value) || value < 0) invalidRequest(`Expected a non-negative integer, got ${value}`);
-	return value;
-}
-/**
-* The ` where a and b` clause for the parts that are present, or an empty
-* string.
-*/
-function whereClause(parts) {
-	const present = parts.filter((part) => part !== void 0);
-	return present.length > 0 ? ` where ${present.join(" and ")}` : "";
-}
-//#endregion
-export { whereClause as n, integer as t };

package/dist/sign-in-B_QJ2u62.js

@@ -1,386 +0,0 @@
-import { t as hasAuthModule } from "./auth-module-CwCIY97x.js";
-import { t as clearOnUserChange } from "./user-change-CSR_prhd.js";
-import { c as liveKey, d as shownCount, f as startBroadcast, g as specKey, h as sessionUserId, i as countSource, m as startLiveQuery, p as startLiveCount, t as NO_COUNT } from "./client-YASsOslj.js";
-import { t as ClientContext } from "./context-CMxVnPMY.js";
-import { useSession } from "./react/session.js";
-import { createElement, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-//#region src/react/hooks.ts
-const LOADING = {
-	status: "loading",
-	user: null,
-	claims: null
-};
-/** Provides the better-supabase client to the hooks. */
-function BetterSupabaseProvider(props) {
-	const { client, queryClient } = props;
-	useEffect(() => queryClient ? clearOnUserChange(queryClient, client.auth) : void 0, [client, queryClient]);
-	const value = useMemo(() => ({
-		client,
-		queryClient
-	}), [client, queryClient]);
-	return createElement(ClientContext.Provider, { value }, props.children);
-}
-function useClientContext() {
-	const value = useContext(ClientContext);
-	if (!value) throw new Error("better-supabase: wrap your app in <BetterSupabaseProvider client={bs}>");
-	return value;
-}
-function useClient() {
-	return useClientContext().client;
-}
-/**
-* The session state for UI: `loading`, `signed-out` or `signed-in` with the
-* user and claims.
-*/
-function useAuth() {
-	const client = useClient();
-	return useSyncExternalStore(client.auth.subscribe, client.auth.current, () => LOADING);
-}
-function useSupabase() {
-	return useClient().supabase;
-}
-/**
-* Hooks typed for your schema.
-*
-* ```ts
-* export const { useDb, useQueries, useAuth } = createHooks<typeof bs>();
-* ```
-*/
-function createHooks() {
-	return {
-		useDb() {
-			const client = useClient();
-			useAuth();
-			return client.db;
-		},
-		useQueries() {
-			const client = useClient();
-			useAuth();
-			return client.queries;
-		},
-		useSupabase,
-		useAuth,
-		useSession
-	};
-}
-/**
-* Subscribes to a topic while mounted. Pass `null` values to pause. It
-* resubscribes when the topic or the signed-in user changes.
-*
-* ```ts
-* useBroadcast(
-*   customersTopic,
-*   organizationId ? { organizationId } : null,
-*   {},
-*   { invalidate: ["customers"] },
-* );
-* ```
-*/
-function useBroadcast(topic, values, handlers, options) {
-	const context = useContext(ClientContext);
-	const supabase = options?.client ?? context?.client.supabase;
-	if (!supabase) throw new Error("better-supabase: useBroadcast needs <BetterSupabaseProvider client={bs}> or { client: supabase }");
-	const queryClient = options?.queryClient ?? context?.queryClient;
-	const auth = useBroadcastAuth(options?.client === void 0 ? context?.client : void 0, supabase);
-	const [status, setStatus] = useState("closed");
-	const latest = useRef({
-		handlers,
-		options
-	});
-	latest.current = {
-		handlers,
-		options
-	};
-	const name = values ? topic.topic(values) : null;
-	const userId = auth.userId;
-	const self = options?.self;
-	if (options?.invalidate && !queryClient) throw new Error("better-supabase: useBroadcast({ invalidate }) needs <BetterSupabaseProvider queryClient={...}> or { queryClient }");
-	useEffect(() => {
-		if (!name || auth.status === "loading") return;
-		return startBroadcast({
-			supabase,
-			topic,
-			name,
-			latest: () => latest.current,
-			queryClient,
-			onStatus: setStatus
-		});
-	}, [
-		supabase,
-		topic,
-		name,
-		userId,
-		auth.status,
-		queryClient,
-		self
-	]);
-	return status;
-}
-const SIGNED_OUT_CALLER = {
-	status: "signed-out",
-	userId: null
-};
-const NO_AUTH = () => () => void 0;
-/**
-* The user `useBroadcast` subscribes as: the provider's auth snapshot, or for a
-* plain supabase-js client, its auth state.
-*/
-function useBroadcastAuth(client, supabase) {
-	const snapshot = useSyncExternalStore(client?.auth.subscribe ?? NO_AUTH, client?.auth.current ?? (() => LOADING), () => LOADING);
-	const [plain, setPlain] = useState({
-		status: "loading",
-		userId: null
-	});
-	useEffect(() => {
-		if (client) return;
-		if (!hasAuthModule(supabase)) return;
-		const { data } = supabase.auth.onAuthStateChange((_event, session) => {
-			setPlain({
-				status: session ? "signed-in" : "signed-out",
-				userId: session ? sessionUserId(session) : null
-			});
-		});
-		return () => {
-			data.subscription.unsubscribe();
-		};
-	}, [client, supabase]);
-	if (client) return {
-		status: snapshot.status,
-		userId: snapshot.user?.id ?? null
-	};
-	return hasAuthModule(supabase) ? plain : SIGNED_OUT_CALLER;
-}
-/**
-* The spec from the render whose key last changed, so effects keep the original
-* values (`bigint`, Temporal) and only rerun on a different query.
-*/
-function useHeldSpec(spec) {
-	const key = spec ? specKey(spec) : null;
-	const [held, setHeld] = useState({
-		key,
-		spec: spec ?? null
-	});
-	if (held.key === key) return held;
-	const next = {
-		key,
-		spec: spec ?? null
-	};
-	setHeld(next);
-	return next;
-}
-/**
-* Keeps a query fresh: invalidates every cached query that read a table the
-* spec touches whenever one of them changes. Pass `null` to pause. It
-* resubscribes when the spec, tenant or user changes.
-*
-* ```ts
-* const spec = betterSupabase.spec.customers.findMany({
-*   include: { notes: true },
-* });
-* const { data } = useQuery(q.$spec(spec));
-* useLiveQuery(spec);
-* ```
-*/
-function useLiveQuery(spec, options = {}) {
-	const { client, queryClient } = useClientContext();
-	const auth = useAuth();
-	const [status, setStatus] = useState("closed");
-	if (spec && !queryClient) throw new Error("better-supabase: useLiveQuery needs <BetterSupabaseProvider queryClient={...}>");
-	const held = useHeldSpec(spec);
-	const joined = useRef(null);
-	const key = liveKey(client, held.spec, auth, options);
-	const latest = useRef({
-		auth,
-		options
-	});
-	latest.current = {
-		auth,
-		options
-	};
-	useEffect(() => {
-		if (key === null || !held.spec || !queryClient) return;
-		const resumed = joined.current === held.key;
-		joined.current = held.key;
-		return startLiveQuery({
-			client,
-			queryClient,
-			spec: held.spec,
-			auth: latest.current.auth,
-			options: latest.current.options,
-			resumed,
-			onStatus: setStatus
-		});
-	}, [
-		client,
-		queryClient,
-		held,
-		key
-	]);
-	return status;
-}
-/**
-* A count that stays current: refetches only the `count` spec (a HEAD request)
-* after each debounced change to a table it reads, and after the channel
-* rejoins. Takes a spec or a `bs.liveCount()` seed; pass `null` to pause.
-* Doesn't need a `QueryClient`.
-*
-* ```tsx
-* const { count } = useLiveCount(seed); // seed = await bs.liveCount(spec)
-* ```
-*/
-function useLiveCount(source, options = {}) {
-	const { client } = useClientContext();
-	const auth = useAuth();
-	const parsed = countSource(source, options);
-	const [state, setState] = useState(NO_COUNT);
-	const stateRef = useRef(NO_COUNT);
-	const [status, setStatus] = useState("closed");
-	const held = useHeldSpec(parsed.spec);
-	const joined = useRef(null);
-	const key = liveKey(client, held.spec, auth, options);
-	const latest = useRef({
-		auth,
-		options
-	});
-	latest.current = {
-		auth,
-		options
-	};
-	const hasInitial = parsed.initial !== void 0;
-	const { seedAt } = parsed;
-	useEffect(() => {
-		if (key === null || !held.spec || held.key === null) return;
-		const specKey = held.key;
-		const previous = joined.current?.key === specKey ? joined.current : null;
-		joined.current = {
-			key: specKey,
-			at: previous?.at ?? seedAt ?? 0
-		};
-		return startLiveCount({
-			client,
-			spec: held.spec,
-			key: specKey,
-			auth: latest.current.auth,
-			options: latest.current.options,
-			immediate: !hasInitial && !previous,
-			since: previous ? previous.at : seedAt,
-			onState: (update) => {
-				const next = update(stateRef.current);
-				stateRef.current = next;
-				if (next.error === void 0 && joined.current?.key === specKey) joined.current = {
-					key: specKey,
-					at: next.at
-				};
-				setState(next);
-			},
-			onStatus: setStatus
-		});
-	}, [
-		client,
-		held.spec,
-		held.key,
-		key,
-		hasInitial,
-		seedAt
-	]);
-	const shown = shownCount(state, held.key, parsed);
-	return {
-		count: shown.count,
-		status,
-		error: shown.error
-	};
-}
-//#endregion
-//#region src/react/sign-in.ts
-function useAuthApi(options, hook) {
-	const context = useContext(ClientContext);
-	const auth = options.client?.auth ?? context?.client.supabase.auth;
-	if (!auth) throw new Error(`better-supabase: ${hook} needs <BetterSupabaseProvider client={bs}> or { client: supabase }`);
-	return auth;
-}
-/**
-* Runs auth calls with `pending` and `error` state; the latest call owns the
-* state.
-*/
-function usePending(options) {
-	const [state, setState] = useState({
-		pending: false,
-		error: void 0
-	});
-	const latest = useRef({
-		call: 0,
-		options
-	});
-	latest.current.options = options;
-	return {
-		state,
-		run: useMemo(() => async (call) => {
-			latest.current.call += 1;
-			const id = latest.current.call;
-			setState({
-				pending: true,
-				error: void 0
-			});
-			let error;
-			try {
-				({error} = await call());
-			} catch (cause) {
-				if (id === latest.current.call) setState({
-					pending: false,
-					error: void 0
-				});
-				throw cause;
-			}
-			if (id === latest.current.call) setState({
-				pending: false,
-				error: error ?? void 0
-			});
-			if (!error) latest.current.options.onSuccess?.();
-			return error ?? void 0;
-		}, [])
-	};
-}
-/**
-* Sign-in calls with `pending` and `error` state. The session lands in the
-* client's auth store, so `useAuth()` updates on its own.
-*
-* ```tsx
-* const signIn = useSignIn({ onSuccess: () => router.push("/") });
-* <button
-*   disabled={signIn.pending}
-*   onClick={() => signIn.password({ email, password })}
-* />;
-* ```
-*/
-function useSignIn(options = {}) {
-	const auth = useAuthApi(options, "useSignIn");
-	const { state, run } = usePending(options);
-	const calls = useMemo(() => ({
-		password: (credentials) => run(() => auth.signInWithPassword({ ...credentials })),
-		otp: (credentials) => run(() => auth.signInWithOtp(credentials)),
-		verifyOtp: (params) => run(() => auth.verifyOtp(params)),
-		oauth: (provider, oauthOptions) => run(() => auth.signInWithOAuth(oauthOptions ? {
-			provider,
-			options: oauthOptions
-		} : { provider }))
-	}), [auth, run]);
-	return {
-		...state,
-		...calls
-	};
-}
-/**
-* `auth.signOut()` with `pending` and `error` state. The provider clears cached
-* queries.
-*/
-function useSignOut(options = {}) {
-	const auth = useAuthApi(options, "useSignOut");
-	const { state, run } = usePending(options);
-	const signOut = useMemo(() => (signOutOptions) => run(() => auth.signOut(signOutOptions ? { ...signOutOptions } : void 0)), [auth, run]);
-	return {
-		...state,
-		signOut
-	};
-}
-//#endregion
-export { createHooks as a, useBroadcastAuth as c, useSupabase as d, BetterSupabaseProvider as i, useLiveCount as l, useSignIn as n, useAuth as o, useSignOut as r, useBroadcast as s, usePending as t, useLiveQuery as u };

package/dist/signatures-CzqfLlfV.d.ts

@@ -1,43 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { f as Result } from "./result-mijqfoJN.js";
-//#region src/core/signatures.d.ts
-interface VerifiedWebhook<T = unknown> {
-  readonly id: string;
-  readonly timestamp: Temporal.Instant;
-  readonly payload: T;
-  readonly body: string;
-}
-interface VerifyOptions {
-  /** Allowed clock skew in seconds. Defaults to 300. */
-  readonly tolerance?: number;
-  readonly now?: () => Temporal.Instant;
-  /**
-   * Records a verified `webhook-id` and answers whether it was already
-   * recorded, atomically (a unique insert, Redis `SET NX`). A seen id is
-   * refused as a replay (`WEBHOOK_REPLAYED`, 409). `until` is when the
-   * timestamp leaves the tolerance window, so the store may forget the id after
-   * it. Runs only after the signature checks out, and a throw refuses the
-   * request.
-   */
-  readonly seen?: (id: string, until: Temporal.Instant) => boolean | Promise<boolean>;
-}
-type WebhookInput = Request | {
-  readonly headers: Headers | Readonly<Record<string, string>>;
-  readonly body: string;
-};
-/** Headers for a signed Standard Webhooks request. */
-declare function signWebhook(secret: string, message: {
-  readonly id: string;
-  readonly body: string;
-  readonly timestamp?: Temporal.Instant;
-}): Promise<Record<string, string>>;
-/**
- * Verifies a Standard Webhooks signature (`webhook-id`, `webhook-timestamp`,
- * `webhook-signature`, or the `svix-` names Svix-based senders use) and parses
- * the JSON body. Pass several secrets while rotating.
- */
-declare function verifyWebhook<T = unknown>(input: WebhookInput, secrets: string | readonly string[], options?: VerifyOptions): Promise<Result<VerifiedWebhook<T>>>;
-/** Checks a shared-secret header (database webhooks), in constant time. */
-declare function verifySharedSecret(request: Request, secret: string, headerName?: string): boolean;
-//#endregion
-export { verifySharedSecret as a, signWebhook as i, VerifyOptions as n, verifyWebhook as o, WebhookInput as r, VerifiedWebhook as t };