better-supabase 0.12.0 → 0.14.0

package/dist/usage-DdqT13_X.js

@@ -1,261 +0,0 @@
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { C as optionalText, D as recordOf, I as textOf, M as seconds, R as toInstant, k as recordsOf, n as applyTemporal, o as blockCall, t as DEFAULT_BLOCK_SCHEMA, u as eachLimit, w as pageOf } from "./block-helpers-DkVZNDrj.js";
-import { r as withBlockHooks } from "./block-hooks-C22vuIUd.js";
-import { t as lazyStripe } from "./stripe-XZrSmDTf.js";
-//#region src/blocks/usage/usage.ts
-const numberOf = (value) => typeof value === "number" ? value : Number(value);
-const optionalNumber = (value) => value === null || value === void 0 ? void 0 : numberOf(value);
-const PERIODS = /* @__PURE__ */ new Set([
-	"day",
-	"week",
-	"month",
-	"year",
-	"billing"
-]);
-const periodOf = (value) => {
-	const text = textOf(value);
-	return PERIODS.has(text) ? text : "month";
-};
-function recordedOf(value) {
-	const row = recordOf(value, "record_usage");
-	return {
-		recorded: row["recorded"] === true,
-		today: numberOf(row["today"]),
-		used: numberOf(row["used"])
-	};
-}
-const perMeter = (value) => isRecord(value) ? Object.fromEntries(Object.entries(value).map(([meter, used]) => [meter, numberOf(used)])) : {};
-function statusOf(value) {
-	const row = recordOf(value, "usage_status");
-	return {
-		meter: textOf(row["meter"]),
-		used: numberOf(row["used"]),
-		limit: optionalNumber(row["limit"]),
-		remaining: optionalNumber(row["remaining"]),
-		unlimited: row["unlimited"] === true,
-		period: periodOf(row["period"]),
-		startsAt: row["starts_at"] === void 0 || row["starts_at"] === null ? void 0 : toInstant(textOf(row["starts_at"])),
-		resetsAt: toInstant(textOf(row["resets_at"])),
-		...meterInfo(row)
-	};
-}
-function meterInfo(row) {
-	const unit = optionalText(row["unit"]);
-	const category = optionalText(row["category"]);
-	const label = optionalText(row["label"]);
-	const kind = optionalText(row["kind"]);
-	const period = optionalText(row["period"]);
-	return {
-		...unit === void 0 ? {} : { unit },
-		...category === void 0 ? {} : { category },
-		...label === void 0 ? {} : { label },
-		...kind === "counter" || kind === "distinct" || kind === "computed" ? { kind } : {},
-		...period === "day" || period === "week" || period === "month" || period === "year" || period === "billing" ? { period } : {}
-	};
-}
-/** Usage metering and quotas over the `usage` module's functions. */
-function createUsage(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const args = (organizationId, meter, record = {}) => ({
-		tenant: organizationId,
-		meter,
-		quantity: record.quantity ?? 1,
-		idempotency_key: record.idempotencyKey,
-		source: record.source,
-		metadata: record.metadata,
-		actor: record.actor
-	});
-	const batch = (check) => (organizationId, entries, record = {}) => call("record_usage_batch", {
-		tenant: organizationId,
-		entries: JSON.stringify(entries.map((entry) => ({
-			meter: entry.meter,
-			quantity: entry.quantity ?? 1
-		}))),
-		idempotency_key: record.idempotencyKey,
-		check,
-		source: record.source,
-		metadata: record.metadata,
-		actor: record.actor
-	}, (value) => {
-		const row = recordOf(value, "record_usage_batch");
-		return {
-			recorded: row["recorded"] === true,
-			today: perMeter(row["today"]),
-			used: perMeter(row["used"])
-		};
-	});
-	const current = (organizationId, meter) => call("usage_status", {
-		tenant: organizationId,
-		meter
-	}, statusOf);
-	const purge = (fn) => (purgeOptions = {}) => call(fn, {
-		older_than: purgeOptions.olderThan === void 0 ? void 0 : seconds(purgeOptions.olderThan),
-		batch: purgeOptions.batch
-	}, (value) => Number(value ?? 0));
-	const purgeHistory = purge("purge_usage_history");
-	const purgeEvents = purge("purge_usage_events");
-	const client = {
-		purgeHistory,
-		purgeEvents,
-		purgeJob: (jobOptions = {}) => async () => ({
-			history: await purgeHistory(jobOptions.history).orThrow(),
-			events: await purgeEvents(jobOptions.events).orThrow()
-		}),
-		record: (organizationId, meter, record) => call("record_usage", args(organizationId, meter, record), recordedOf),
-		track: (organizationId, meter, subject, trackOptions = {}) => call("track_usage", {
-			tenant: organizationId,
-			meter,
-			subject,
-			period: trackOptions.period ?? "month"
-		}, recordedOf),
-		refresh: (meter) => call("usage_refresh", { meter }, (value) => Number(value ?? 0)),
-		consume: (organizationId, meter, record) => call("consume_quota", args(organizationId, meter, record), recordedOf),
-		recordMany: batch(false),
-		consumeMany: batch(true),
-		current,
-		overview: (organizationId) => call("usage_overview", { tenant: organizationId }, (value) => (Array.isArray(value) ? value : []).map(statusOf)),
-		remaining: (organizationId, meter) => current(organizationId, meter).map((status) => status.remaining),
-		history: (organizationId, list = {}) => call("usage_history", {
-			tenant: organizationId,
-			meter: list.meter,
-			max_rows: list.limit ?? 100,
-			before_id: pageOf(list).cursor
-		}, (value) => (Array.isArray(value) ? value.filter(isRecord) : []).map((row) => ({
-			id: numberOf(row["id"]),
-			meter: textOf(row["meter"]),
-			quantity: numberOf(row["quantity"]),
-			actor: optionalText(row["actor"]),
-			source: optionalText(row["source"]),
-			metadata: isRecord(row["metadata"]) ? row["metadata"] : {},
-			recordedAt: toInstant(textOf(row["recorded_at"]))
-		}))),
-		breakdown: (organizationId, meter) => call("usage_breakdown", {
-			tenant: organizationId,
-			meter
-		}, (value) => (Array.isArray(value) ? value.filter(isRecord) : []).map((row) => ({
-			actor: optionalText(row["actor"]),
-			source: optionalText(row["source"]),
-			quantity: numberOf(row["quantity"])
-		}))),
-		meters: () => call("usage_meters", {}, (value) => {
-			const row = isRecord(value) ? value : {};
-			return Object.fromEntries(Object.entries(row).map(([meter, info]) => [meter, meterInfo(isRecord(info) ? info : {})]));
-		})
-	};
-	return withBlockHooks(client, options.hooks, {
-		block: "usage",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-/** Customer lookups, and meter events with their marks, in flight at once. */
-const REPORT_CONCURRENCY = 8;
-/**
-* Sends unreported usage to Stripe as meter events, one per counter and
-* delta. The event `identifier` is the tenant, meter, day and new total, so
-* a run that fails after sending and before marking resends the same event,
-* and Stripe drops the duplicate. Run it from a job or a cron route.
-*/
-async function reportUsageToStripe(options) {
-	const call = blockCall(options.transport, options.schema);
-	const entitlements = blockCall(options.transport, DEFAULT_BLOCK_SCHEMA);
-	const stripe = await lazyStripe(options.stripe)();
-	const customers = /* @__PURE__ */ new Map();
-	const customerOf = options.customer ?? (async (organizationId) => entitlements("tenant_stripe_customer", { tenant: organizationId }, optionalText).orThrow());
-	const limit = options.batch ?? 500;
-	const skipMeters = /* @__PURE__ */ new Set();
-	const skipTenants = /* @__PURE__ */ new Set();
-	/** Sends the meter event when there is a delta, then marks the total; `true` when it sent one. */
-	const send = async (pending) => {
-		const { organizationId, meter, day, value, delta, identifier } = pending;
-		if (delta > 0) await stripe.billing.meterEvents.create({
-			event_name: pending.eventName,
-			payload: {
-				stripe_customer_id: pending.customer,
-				value: String(delta)
-			},
-			identifier,
-			timestamp: Math.floor(Math.min(Date.now(), Date.parse(`${day}T23:59:59Z`)) / 1e3)
-		}, { idempotencyKey: identifier });
-		await call("mark_usage_reported", {
-			tenant: organizationId,
-			meter,
-			day,
-			value
-		}, () => void 0).orThrow();
-		return delta > 0;
-	};
-	let reported = 0;
-	let skipped = 0;
-	let handled = 0;
-	for (;;) {
-		const rows = await call("unreported_usage", {
-			max_rows: limit - handled,
-			skip_meters: [...skipMeters],
-			skip_tenants: [...skipTenants]
-		}, (value) => recordsOf(value, "unreported_usage")).orThrow();
-		let passedOver = false;
-		const eventNameOf = (meter) => options.eventName ? options.eventName(meter) : meter;
-		const lookups = /* @__PURE__ */ new Set();
-		for (const row of rows) {
-			const organizationId = textOf(row["organization_id"]);
-			if (!customers.has(organizationId) && !skipTenants.has(organizationId) && eventNameOf(textOf(row["meter"])) !== void 0) lookups.add(organizationId);
-		}
-		await eachLimit([...lookups], REPORT_CONCURRENCY, async (organizationId) => {
-			customers.set(organizationId, await customerOf(organizationId));
-		});
-		const sends = [];
-		for (const row of rows) {
-			const organizationId = textOf(row["organization_id"]);
-			const meter = textOf(row["meter"]);
-			if (skipMeters.has(meter) || skipTenants.has(organizationId)) {
-				skipped += 1;
-				continue;
-			}
-			const eventName = eventNameOf(meter);
-			if (eventName === void 0) {
-				skipMeters.add(meter);
-				skipped += 1;
-				passedOver = true;
-				continue;
-			}
-			const customer = customers.get(organizationId);
-			if (customer === void 0) {
-				skipTenants.add(organizationId);
-				skipped += 1;
-				passedOver = true;
-				continue;
-			}
-			handled += 1;
-			const day = textOf(row["day"]).slice(0, 10);
-			const value = numberOf(row["value"]);
-			const previous = numberOf(row["reported_value"]);
-			const included = optionalNumber(row["included"]);
-			const before = numberOf(row["window_before"] ?? 0);
-			const delta = options.overage === true && row["unlimited"] === true ? 0 : options.overage === true && included !== void 0 ? Math.max(0, before + value - included) - Math.max(0, before + previous - included) : value - previous;
-			const identifier = `${organizationId}:${meter}:${day}:${String(value)}`;
-			sends.push({
-				organizationId,
-				meter,
-				day,
-				value,
-				delta,
-				eventName,
-				customer,
-				identifier
-			});
-		}
-		const sent = [];
-		await eachLimit(sends, REPORT_CONCURRENCY, async (pending, index) => {
-			sent[index] = await send(pending);
-		});
-		reported += sent.filter(Boolean).length;
-		if (!passedOver || handled >= limit || rows.length === 0) break;
-	}
-	return {
-		reported,
-		skipped
-	};
-}
-//#endregion
-export { reportUsageToStripe as n, createUsage as t };

package/dist/user-change-XzvgafU4.js

@@ -1,130 +0,0 @@
-//#region src/query/invalidate.ts
-function isString(value) {
-	return typeof value === "string";
-}
-function queryTables(query) {
-	const tables = query.meta?.["bsTables"];
-	if (Array.isArray(tables)) {
-		const list = tables;
-		return list.every(isString) ? list : list.filter(isString);
-	}
-	const [prefix, table] = query.queryKey;
-	return prefix === "bs" && typeof table === "string" ? [table] : void 0;
-}
-const indexes = /* @__PURE__ */ new WeakMap();
-function indexOf(cache) {
-	const existing = indexes.get(cache);
-	if (existing) return existing;
-	const index = {
-		byTable: /* @__PURE__ */ new Map(),
-		tablesOf: /* @__PURE__ */ new Map()
-	};
-	const remove = (hash) => {
-		for (const table of index.tablesOf.get(hash) ?? []) {
-			const set = index.byTable.get(table);
-			set?.delete(hash);
-			if (set?.size === 0) index.byTable.delete(table);
-		}
-		index.tablesOf.delete(hash);
-	};
-	const add = (hash) => {
-		const query = cache.get(hash);
-		const tables = query ? queryTables(query) : void 0;
-		const known = index.tablesOf.get(hash);
-		if (known !== void 0 && tables !== void 0 && known.length === tables.length && known.every((table, at) => table === tables[at])) return;
-		remove(hash);
-		if (!tables || tables.length === 0) return;
-		index.tablesOf.set(hash, tables);
-		for (const table of tables) {
-			let set = index.byTable.get(table);
-			if (!set) index.byTable.set(table, set = /* @__PURE__ */ new Set());
-			set.add(hash);
-		}
-	};
-	for (const query of cache.getAll()) add(query.queryHash);
-	cache.subscribe((event) => {
-		const hash = event.query.queryHash;
-		if (event.type === "removed") remove(hash);
-		else if (event.type === "added" || event.type === "observerAdded" || event.type === "observerOptionsUpdated" || event.type === "updated" && event.action.type === "fetch") add(hash);
-	});
-	indexes.set(cache, index);
-	return index;
-}
-/**
-* Invalidates every query that read one of `tables`: better-supabase queries
-* by their `meta.bsTables`, and other `['bs', table, ...]` keys by prefix.
-* An index from table to queries finds them, so a write to a table nothing
-* read skips the cache scan.
-*/
-function invalidateTables(client, tables) {
-	if (tables.length === 0) return Promise.resolve();
-	const { byTable } = indexOf(client.getQueryCache());
-	const matched = /* @__PURE__ */ new Set();
-	for (const table of tables) for (const hash of byTable.get(table) ?? []) matched.add(hash);
-	if (matched.size === 0) return Promise.resolve();
-	return client.invalidateQueries({ predicate: (query) => matched.has(query.queryHash) });
-}
-//#endregion
-//#region src/query/user-change.ts
-/** Claims every refresh changes; the rest says who the caller is and what RLS lets them read. */
-const TIME_CLAIMS = /* @__PURE__ */ new Set([
-	"exp",
-	"iat",
-	"nbf",
-	"jti"
-]);
-/**
-* The user plus every claim except the time claims, so a token refresh keeps
-* the identity and an organization switch, a role change or a second factor
-* (a new `tenant_id`, `role` or `aal`) changes it.
-*/
-function identityKey(snapshot) {
-	if (!snapshot.user) return null;
-	const claims = Object.entries(snapshot.claims ?? {}).filter(([key]) => !TIME_CLAIMS.has(key)).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-	return JSON.stringify([snapshot.user.id, claims]);
-}
-/**
-* Resets every `['bs', ...]` query when the caller changes: another user,
-* signing out, or new claims for the same user (an organization switch, a
-* role change). Mounted queries refetch, so no one sees the previous
-* identity's rows. Returns the function that stops listening.
-* `BetterSupabaseProvider` calls it for React; call it yourself with Vue,
-* Solid, Svelte or Angular Query.
-*
-* Queries that fetched while the session was still loading ran as anon, so
-* they are reset when a user arrives. Data already in the cache when loading
-* started (hydrated from the server) stays.
-*
-* ```ts
-* const stop = clearOnUserChange(queryClient, bs.auth);
-* ```
-*/
-function clearOnUserChange(queryClient, auth) {
-	let identity;
-	let before;
-	const bsQueries = () => queryClient.getQueryCache().findAll({ queryKey: ["bs"] });
-	const check = () => {
-		const snapshot = auth.current();
-		if (snapshot.status === "loading") {
-			before ??= new Map(bsQueries().map((query) => [query.queryHash, query.state.dataUpdatedAt]));
-			return;
-		}
-		const next = identityKey(snapshot);
-		if (identity !== void 0 && identity !== next) queryClient.resetQueries({ queryKey: ["bs"] });
-		else if (identity === void 0 && next !== null && before) {
-			const known = before;
-			const fetchedAsAnon = new Set(bsQueries().filter((query) => query.state.dataUpdatedAt > 0 && known.get(query.queryHash) !== query.state.dataUpdatedAt).map((query) => query.queryHash));
-			if (fetchedAsAnon.size > 0) queryClient.resetQueries({
-				queryKey: ["bs"],
-				predicate: (query) => fetchedAsAnon.has(query.queryHash)
-			});
-		}
-		before = void 0;
-		identity = next;
-	};
-	const stop = auth.subscribe(check);
-	check();
-	return stop;
-}
-//#endregion
-export { identityKey as n, invalidateTables as r, clearOnUserChange as t };

package/dist/vault-ClkzMGTP.d.ts

@@ -1,50 +0,0 @@
-import { T as ErrorMapper, t as AsyncResult } from "./result-BREt7qOh.js";
-import { c as SetCredentialOptions, i as CredentialRef, r as CredentialProvider } from "./provider-DXgx5oSA.js";
-import { t as BlockTransport } from "./block-transport-DezJPPA0.js";
-//#region src/credentials/vault.d.ts
-/** How a request the third party sends is signed with the stored secret. */
-type VaultInboundScheme = "standard-webhooks" | "hmac-sha256" | "shared-secret";
-/**
- * A credential in Vault. `scope: 'user'` keeps one secret per user subject.
- * The token goes out as `<header>: <scheme> <token>`, `Authorization: Bearer`
- * by default; `scheme: null` sends it bare (`x-api-key`).
- */
-interface VaultCredentialRef {
-  readonly provider: "vault";
-  readonly secret: string;
-  /** Stores the secret as `tenant/<tenant>/<secret>`, apart from every other tenant's. */
-  readonly tenant?: string;
-  readonly scope?: "app" | "user";
-  readonly header?: string;
-  readonly scheme?: string | null;
-  readonly inbound?: VaultInboundScheme;
-  /** Defaults to `x-hub-signature-256` for `hmac-sha256`, `authorization` for `shared-secret`. */
-  readonly signatureHeader?: string;
-}
-interface VaultCredentialsOptions {
-  /** `sqlTransport(postgres.asService())` or `rpcTransport` with the service role key. */
-  readonly transport: BlockTransport;
-  /** The schema of the `credentials` module. Defaults to `better_supabase`. */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
-  /**
-   * How long a read secret stays in memory, in milliseconds. Defaults to
-   * 60000; `0` reads Vault on every call. `set` and `revoke` clear it.
-   */
-  readonly cacheMs?: number;
-}
-interface VaultCredentials extends CredentialProvider {
-  readonly name: "vault";
-  /** Stores or replaces the credential a ref names, for `subject` when the ref is per user. */
-  set(ref: CredentialRef, value: string, options?: SetCredentialOptions): AsyncResult<void>;
-  verifyInbound(request: Request, ref: CredentialRef): AsyncResult<boolean>;
-}
-/**
- * A `CredentialProvider` over the `credentials` SQL module: tokens and API
- * keys in Supabase Vault, read through security definer functions only the
- * service role may call. Static secrets only; OAuth connections come from
- * a provider such as `better-supabase/vercel-connect`.
- */
-declare function vaultCredentials(options: VaultCredentialsOptions): VaultCredentials;
-//#endregion
-export { vaultCredentials as a, VaultInboundScheme as i, VaultCredentials as n, VaultCredentialsOptions as r, VaultCredentialRef as t };

package/dist/verify-DU4p9-Ve.d.ts

@@ -1,142 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { f as Result } from "./result-BREt7qOh.js";
-import { B as TableKey, N as Row, a as AnyModels, i as AnyFunctions } from "./types-BrpW5ixT.js";
-import { t as BetterSupabase } from "./define-DYZnvAbs.js";
-import { n as VerifyOptions, r as WebhookInput, t as VerifiedWebhook } from "./signatures-BXlDXV3D.js";
-//#region src/blocks/webhooks/verify.d.ts
-/** The `Stripe-Signature` header for `body`, for tests and local replays. */
-declare function signStripeWebhook(secret: string, body: string, timestamp?: Temporal.Instant): Promise<string>;
-/**
- * Verifies a `Stripe-Signature` header (`t=…,v1=…`) with the endpoint's
- * `whsec_…` secret and parses the event. Pass several secrets while rolling
- * the endpoint secret. Runs on WebCrypto, so it needs no `stripe` package.
- */
-declare function verifyStripeWebhook<T = unknown>(input: WebhookInput, secrets: string | readonly string[], options?: VerifyOptions): Promise<Result<VerifiedWebhook<T>>>;
-/**
- * `createWebhookInbox({ source: 'stripe', verify: stripeInboxVerify(secret) })`:
- * stores Stripe events keyed by their event id.
- */
-declare function stripeInboxVerify(secrets: string | readonly string[], options?: VerifyOptions): (request: Request, body: string) => Promise<Result<{
-  id: string;
-  payload: unknown;
-}>>;
-interface HookUser {
-  readonly id: string;
-  readonly email?: string;
-  readonly phone?: string;
-  readonly app_metadata?: Readonly<Record<string, unknown>>;
-  readonly user_metadata?: Readonly<Record<string, unknown>>;
-  readonly [key: string]: unknown;
-}
-interface AuthHookError {
-  readonly error: {
-    readonly http_code: number;
-    readonly message: string;
-  };
-}
-interface AuthHooks {
-  custom_access_token: {
-    input: {
-      readonly user_id: string;
-      readonly claims: Readonly<Record<string, unknown>> & {
-        readonly sub: string;
-        readonly role: string;
-      };
-      readonly authentication_method: string;
-    };
-    output: {
-      readonly claims: Readonly<Record<string, unknown>>;
-    };
-  };
-  send_email: {
-    input: {
-      readonly user: HookUser;
-      readonly email_data: {
-        readonly token: string;
-        readonly token_hash: string;
-        readonly redirect_to: string;
-        readonly email_action_type: string;
-        readonly site_url: string;
-        readonly token_new: string;
-        readonly token_hash_new: string;
-        /** Auth adds fields over time (`old_email`, `factor_type`, ...). */
-        readonly [key: string]: unknown;
-      };
-    };
-    output: Record<never, never>;
-  };
-  send_sms: {
-    input: {
-      readonly user: HookUser;
-      readonly sms: {
-        readonly otp: string;
-      };
-    };
-    output: Record<never, never>;
-  };
-  mfa_verification_attempt: {
-    input: {
-      readonly factor_id: string;
-      readonly factor_type: string;
-      readonly user_id: string;
-      readonly valid: boolean;
-    };
-    output: {
-      readonly decision: "continue" | "reject";
-      readonly message?: string;
-    };
-  };
-  password_verification_attempt: {
-    input: {
-      readonly user_id: string;
-      readonly valid: boolean;
-    };
-    output: {
-      readonly decision: "continue" | "reject";
-      readonly message?: string;
-      readonly should_logout_user?: boolean;
-    };
-  };
-  before_user_created: {
-    input: {
-      readonly metadata: Readonly<Record<string, unknown>>;
-      readonly user: HookUser;
-    };
-    output: Record<never, never>;
-  };
-}
-type AuthHookKind = keyof AuthHooks;
-/** Rejects a hook with a status and message Supabase Auth passes to the client. */
-declare function hookError(status: number, message: string): AuthHookError;
-/**
- * A `(request) => Response` handler for a Supabase Auth hook: verifies the
- * Standard Webhooks signature, types the payload and serializes the answer.
- *
- * ```ts
- * export const POST = authHook('custom_access_token', env.AUTH_HOOK_SECRET, async ({ claims, user_id }) => ({
- *   claims: { ...claims, tenant_id: await organizationFor(user_id) },
- * }));
- * ```
- */
-declare function authHook<K extends AuthHookKind>(_kind: K, secret: string | readonly string[], handler: (payload: AuthHooks[K]["input"], webhook: VerifiedWebhook<AuthHooks[K]["input"]>) => AuthHooks[K]["output"] | AuthHookError | Promise<AuthHooks[K]["output"] | AuthHookError>, options?: VerifyOptions): (request: Request) => Promise<Response>;
-interface DatabaseWebhookPayload {
-  readonly type: "INSERT" | "UPDATE" | "DELETE";
-  readonly table: string;
-  readonly schema: string;
-  readonly record: Readonly<Record<string, unknown>> | null;
-  readonly old_record: Readonly<Record<string, unknown>> | null;
-}
-interface DatabaseChange<R> {
-  readonly type: "INSERT" | "UPDATE" | "DELETE";
-  readonly table: string;
-  readonly record: R | null;
-  readonly oldRecord: Partial<R> | null;
-}
-declare function isDatabaseWebhook(value: unknown): value is DatabaseWebhookPayload;
-/**
- * Reads a database webhook payload for `table` as an app-cased change.
- * Returns `null` for other tables or payloads that aren't database webhooks.
- */
-declare function databaseChange<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, F, E>, table: T, payload: unknown): DatabaseChange<Row<M, T>> | null;
-//#endregion
-export { DatabaseWebhookPayload as a, hookError as c, stripeInboxVerify as d, verifyStripeWebhook as f, DatabaseChange as i, isDatabaseWebhook as l, AuthHookKind as n, authHook as o, AuthHooks as r, databaseChange as s, AuthHookError as t, signStripeWebhook as u };