better-supabase 0.4.0 → 0.5.0

package/dist/edge/index.js

@@ -1,7 +1,7 @@
-import { n as dbError } from "../errors-L0xK41y_.js";
-import { a as problemResponse } from "../problem-BihjPR0t.js";
-import { a as guard, i as defaultExpose, n as extendServer, s as respond, t as createServer } from "../server-BA75B0mT.js";
-import { t as defineResource } from "../resource-My_y-Syh.js";
+import { n as dbError } from "../errors-DtwXa6b8.js";
+import { a as problemResponse } from "../problem-BW1KhzSG.js";
+import { d as guard, n as createServer, p as respond, r as extendServer, u as defaultExpose } from "../server-Csx2sRjg.js";
+import { t as defineResource } from "../resource-CRxxwkQq.js";
 //#region src/edge/index.ts
 const SUPABASE_CORS_HEADERS = [
 	"authorization",
@@ -56,7 +56,7 @@ function createEdge(betterSupabase, options = {}) {
 	const cors = options.cors === true ? {} : options.cors === false ? void 0 : options.cors;
 	const corsHeaders = cors ? corsFor(cors) : void 0;
 	const serve = (run, handlerOptions, early) => {
-		return async (request) => {
+		return async (request, _env, executionContext) => {
 			const extra = corsHeaders?.(request);
 			if (cors && request.method === "OPTIONS") return new Response(null, {
 				status: 204,
@@ -79,7 +79,10 @@ function createEdge(betterSupabase, options = {}) {
 					expose
 				});
 			}
-			response = ctx.resolution.apply(response);
+			response = ctx.apply(response);
+			const { events } = betterSupabase;
+			const waitUntil = options.waitUntil ?? executionContext?.waitUntil.bind(executionContext);
+			if (events.pending && waitUntil) waitUntil(events.settled());
 			return extra ? withHeaders(response, extra) : response;
 		};
 	};
@@ -107,7 +110,7 @@ function createEdge(betterSupabase, options = {}) {
 				try {
 					key = id === void 0 || id === "" ? void 0 : decodeURIComponent(id);
 				} catch {
-					return problemResponse(dbError("invalid_request", `Malformed id in ${pathname}`), { instance: pathname });
+					return problemResponse(dbError("invalid_input", `Malformed id in ${pathname}`), { instance: pathname });
 				}
 				routes.set(request, {
 					handler,

package/dist/{entitlements-Dm-FHpNH.d.ts → entitlements-DUxU4oHe.d.ts}

@@ -1,4 +1,4 @@
-import { t as AuthSession } from "./view-B64o81wp.js";
+import { t as AuthSession } from "./view-BEf0diC5.js";
 //#region src/auth/entitlements.d.ts
 /**
  * One entry of the `memberships` claim, in PermDock's shape. PermDock strips

package/dist/env/index.d.ts

@@ -1,2 +1,2 @@
-import { a as EnvResult, c as PublicEnv, d as parseEnv, f as publicEnv, i as EnvOptions, l as envSchema, n as ENV_VARIABLES, o as EnvSource, p as toServerEnv, r as EnvIssue, s as EnvValidationError, t as BetterSupabaseEnv, u as loadEnv } from "../index-Dy6kuF0P.js";
-export { BetterSupabaseEnv, ENV_VARIABLES, EnvIssue, EnvOptions, EnvResult, EnvSource, EnvValidationError, PublicEnv, envSchema, loadEnv, parseEnv, publicEnv, toServerEnv };
+import { a as EnvResult, c as InlineJwks, d as loadEnv, f as parseEnv, i as EnvOptions, l as PublicEnv, m as toServerEnv, n as ENV_VARIABLES, o as EnvSource, p as publicEnv, r as EnvIssue, s as EnvValidationError, t as BetterSupabaseEnv, u as envSchema } from "../index-CLg87OBW.js";
+export { BetterSupabaseEnv, ENV_VARIABLES, EnvIssue, EnvOptions, EnvResult, EnvSource, EnvValidationError, InlineJwks, PublicEnv, envSchema, loadEnv, parseEnv, publicEnv, toServerEnv };

package/dist/env/index.js

@@ -13,6 +13,7 @@ const ENV_VARIABLES = {
 	secretKey: ["SUPABASE_SECRET_KEY"],
 	dbUrl: ["SUPABASE_DB_URL", "DATABASE_URL"],
 	jwksUrl: ["SUPABASE_JWKS_URL"],
+	jwks: ["SUPABASE_JWKS"],
 	readUrl: ["SUPABASE_READ_URL"]
 };
 const LOOPBACK = /^(localhost|127(?:\.\d{1,3}){3}|\[::1\])$/;
@@ -57,6 +58,35 @@ function preferred(keys) {
 	if (!keys) return void 0;
 	return keys["default"] ?? Object.values(keys)[0];
 }
+function isJwk(value) {
+	return typeof value === "object" && value !== null && "kty" in value && typeof value.kty === "string";
+}
+/** At least one key, each an object with a string `kty`, the shape the verifier reads. */
+function isJwkList(value) {
+	return Array.isArray(value) && value.length > 0 && value.every(isJwk);
+}
+/** `SUPABASE_JWKS` as `@supabase/server` reads it: `{"keys":[...]}` or `[...]`. */
+function checkJwks(raw, issues) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		issues.push({
+			variables: ENV_VARIABLES.jwks,
+			message: "must be JSON: {\"keys\":[...]} or [...]"
+		});
+		return;
+	}
+	const keys = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? "keys" in parsed ? parsed.keys : void 0 : parsed;
+	if (!isJwkList(keys)) {
+		issues.push({
+			variables: ENV_VARIABLES.jwks,
+			message: "must hold at least one JSON Web Key with a kty"
+		});
+		return;
+	}
+	return { keys };
+}
 function checkUrl(value, variables, issues) {
 	let url;
 	try {
@@ -132,6 +162,8 @@ function parseEnv(source, options = {}) {
 	});
 	const rawJwks = first(source, ENV_VARIABLES.jwksUrl);
 	const jwksOverride = rawJwks ? checkUrl(rawJwks, ENV_VARIABLES.jwksUrl, issues) : void 0;
+	const rawInline = first(source, ENV_VARIABLES.jwks);
+	const jwks = rawInline ? checkJwks(rawInline, issues) : void 0;
 	const rawRead = first(source, ENV_VARIABLES.readUrl);
 	const readUrl = rawRead ? checkUrl(rawRead, ENV_VARIABLES.readUrl, issues) : void 0;
 	if (issues.length > 0 || !url || !publishableKey) return {
@@ -146,6 +178,7 @@ function parseEnv(source, options = {}) {
 			url: base,
 			publishableKey,
 			jwksUrl: jwksOverride ?? new URL(`${base}/auth/v1/.well-known/jwks.json`),
+			...jwks ? { jwks } : {},
 			...secretKey ? {
 				secretKey,
 				secretKeys: {
@@ -197,7 +230,7 @@ function toServerEnv(env) {
 		url: env.url,
 		publishableKeys: { default: env.publishableKey },
 		secretKeys: env.secretKeys ?? (env.secretKey ? { default: env.secretKey } : {}),
-		jwks: env.jwksUrl
+		jwks: env.jwks ?? env.jwksUrl
 	};
 }
 //#endregion

package/dist/{errors-L0xK41y_.js → errors-DtwXa6b8.js}

@@ -9,6 +9,7 @@ const STATUS = {
 	not_null: 422,
 	exclusion: 409,
 	invalid_input: 400,
+	invalid_value: 500,
 	raised: 400,
 	timeout: 504,
 	serialization: 409,

package/dist/events/index.d.ts

@@ -1,2 +1,3 @@
-import { a as HttpMode, c as RowEventData, d as httpSink, f as isCloudEvent, i as ForwardOptions, l as forwardMutations, m as toHttp, n as CloudEventOptions, o as HttpSinkOptions, p as toCloudEvents, r as EventSink, s as ROW_EVENT_TYPES, t as CloudEvent, u as fromHttp } from "../index-D5IfUIDh.js";
-export { CloudEvent, CloudEventOptions, EventSink, ForwardOptions, HttpMode, HttpSinkOptions, ROW_EVENT_TYPES, RowEventData, forwardMutations, fromHttp, httpSink, isCloudEvent, toCloudEvents, toHttp };
+import { C as kitEventAttributes, S as WebhookEventData, _ as KitEventType, b as OrgEventData, d as InvitationEventData, f as KIT_ATTRIBUTES, g as KitEventPattern, h as KitEventMeta, m as KitEventMap, p as KitEvent, v as KitEventsMatching, w as onKitEvent, x as SupportEventData, y as NotificationEventData } from "../events-aIO7vsIk.js";
+import { _ as toHttp, a as ForwardOptions, c as ROW_EVENT_TYPES, d as forwardMutations, f as fromHttp, g as toCloudEvents, h as kitCloudEvent, i as ForwardKitOptions, l as RowEventData, m as isCloudEvent, n as CloudEventOptions, o as HttpMode, p as httpSink, r as EventSink, s as HttpSinkOptions, t as CloudEvent, u as forwardKitEvents } from "../index-DOESKG27.js";
+export { CloudEvent, CloudEventOptions, EventSink, ForwardKitOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InvitationEventData, KIT_ATTRIBUTES, type KitEvent, type KitEventMap, type KitEventMeta, type KitEventPattern, type KitEventType, type KitEventsMatching, type NotificationEventData, type OrgEventData, ROW_EVENT_TYPES, RowEventData, type SupportEventData, type WebhookEventData, forwardKitEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, kitCloudEvent, kitEventAttributes, onKitEvent, toCloudEvents, toHttp };

package/dist/events/index.js

@@ -1,10 +1,12 @@
-import { n as nowInstant } from "../temporal-BwshQk0W.js";
+import { n as nowInstant } from "../temporal-CVlIV2DZ.js";
+import { i as onKitEvent, r as kitEventAttributes, t as KIT_ATTRIBUTES } from "../kit-events-CTFDfSwb.js";
 //#region src/events/index.ts
 const ROW_EVENT_TYPES = {
 	insert: "dev.better-supabase.row.created",
 	upsert: "dev.better-supabase.row.upserted",
 	update: "dev.better-supabase.row.updated",
-	delete: "dev.better-supabase.row.deleted"
+	delete: "dev.better-supabase.row.deleted",
+	softDelete: "dev.better-supabase.row.softdeleted"
 };
 function subjectOf(meta, table, row) {
 	const key = meta?.tables[table]?.primaryKey;
@@ -15,13 +17,19 @@ function subjectOf(meta, table, row) {
 }
 /**
 * One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
-* app-cased row as `data`, the primary key as `subject`, the tenant as
-* `partitionkey` and the actor as `actorid`.
+* app-cased row and the actor in `data`, the primary key as `subject` and the
+* tenant as `partitionkey`. Writes that return no rows (soft
+* deletes, `returning: false`) send one event per known primary key, with the
+* key as `row`.
 */
 function toCloudEvents(notice, options) {
-	const type = options.typePrefix ? `${options.typePrefix}.row.${ROW_EVENT_TYPES[notice.kind].split(".").at(-1)}` : ROW_EVENT_TYPES[notice.kind];
+	const intent = notice.intent ?? notice.kind;
+	const type = options.typePrefix ? `${options.typePrefix}.row.${ROW_EVENT_TYPES[intent].split(".").at(-1)}` : ROW_EVENT_TYPES[intent];
 	const time = (options.now ?? nowInstant)().toString();
-	return notice.rows.map((row) => {
+	const tenant = notice.tenant ?? notice.context.tenant;
+	const rows = notice.rows.length > 0 ? notice.rows : notice.keys ?? [];
+	const actorId = notice.context.actor?.id;
+	return rows.map((row) => {
 		const subject = subjectOf(options.meta, notice.table, row);
 		return {
 			specversion: "1.0",
@@ -33,16 +41,18 @@ function toCloudEvents(notice, options) {
 			datacontenttype: "application/json",
 			data: {
 				table: notice.table,
-				row
+				row,
+				...actorId ? { actorId } : {}
 			},
-			...notice.context.tenant ? { partitionkey: notice.context.tenant } : {},
-			...notice.context.actor?.id ? { actorid: notice.context.actor.id } : {}
+			...tenant ? { partitionkey: tenant } : {}
 		};
 	});
 }
 /**
 * Sends a CloudEvent for every mutation to `sink`. Returns a function that
-* stops forwarding. Use an outbox (SQL kit) when events must not be lost.
+* stops forwarding. Sends in flight are tracked on `betterSupabase.events`
+* (`settled()`), which the Next adapter hands to `after()` and the edge
+* entry to `waitUntil`. Use an outbox (SQL kit) when events must not be lost.
 */
 function forwardMutations(betterSupabase, sink, options) {
 	return betterSupabase.events.on("mutation", (notice) => {
@@ -58,7 +68,50 @@ function forwardMutations(betterSupabase, sink, options) {
 			}))(error, events);
 		};
 		try {
-			Promise.resolve(sink.send(events)).catch(report);
+			betterSupabase.events.track(Promise.resolve(sink.send(events)).catch(report));
+		} catch (error) {
+			report(error);
+		}
+	});
+}
+/**
+* A kit event as a CloudEvent: `dev.better-supabase.support.started` with
+* the event data and the actor (`actorId`) as `data` and the tenant as
+* `partitionkey`.
+*/
+function kitCloudEvent(event, options) {
+	return {
+		specversion: "1.0",
+		id: options.id?.() ?? crypto.randomUUID(),
+		source: options.source,
+		type: `${options.typePrefix ?? "dev.better-supabase"}.${event.type}`,
+		...event.subject ? { subject: event.subject } : {},
+		time: (options.now?.() ?? event.time).toString(),
+		datacontenttype: "application/json",
+		data: event.actorId ? {
+			...event.data,
+			actorId: event.actorId
+		} : event.data,
+		...event.tenant ? { partitionkey: event.tenant } : {}
+	};
+}
+/**
+* Sends a CloudEvent for every kit event (`support.*`, `org.*`, ...) to
+* `sink`. Returns a function that stops forwarding. Like
+* `forwardMutations`, sends are tracked on `betterSupabase.events`.
+*/
+function forwardKitEvents(betterSupabase, sink, options) {
+	const types = options.types;
+	return betterSupabase.events.on("kit", (event) => {
+		if (types && !types.some((pattern) => pattern.endsWith(".*") ? event.type.startsWith(pattern.slice(0, -1)) : pattern === event.type)) return;
+		const events = [kitCloudEvent(event, options)];
+		const report = (error) => {
+			(options.onError ?? ((cause) => {
+				betterSupabase.events.logger.error("event sink failed", { cause });
+			}))(error, events);
+		};
+		try {
+			betterSupabase.events.track(Promise.resolve(sink.send(events)).catch(report));
 		} catch (error) {
 			report(error);
 		}
@@ -137,4 +190,4 @@ function httpSink(url, options = {}) {
 	} };
 }
 //#endregion
-export { ROW_EVENT_TYPES, forwardMutations, fromHttp, httpSink, isCloudEvent, toCloudEvents, toHttp };
+export { KIT_ATTRIBUTES, ROW_EVENT_TYPES, forwardKitEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, kitCloudEvent, kitEventAttributes, onKitEvent, toCloudEvents, toHttp };

package/dist/events-aIO7vsIk.d.ts

@@ -0,0 +1,230 @@
+/// <reference lib="esnext.temporal" />
+import { U as Operation, _ as DbError } from "./executor-BunPOO-k.js";
+import { g as RequestContext, l as MutationIntent, u as MutationKind } from "./plugin-o144f322.js";
+//#region src/core/logger.d.ts
+type LogFields = Readonly<Record<string, unknown>>;
+/**
+ * Where better-supabase reports problems it swallows on purpose: event
+ * handlers, `afterMutation` hooks, sinks and cache adapters that throw.
+ * Structured loggers (pino, consola, OpenTelemetry logs) fit directly.
+ */
+interface Logger {
+  debug(message: string, fields?: LogFields): void;
+  info(message: string, fields?: LogFields): void;
+  warn(message: string, fields?: LogFields): void;
+  error(message: string, fields?: LogFields): void;
+}
+/** The default: `console`, with a `better-supabase:` prefix. */
+declare const consoleLogger: Logger;
+declare const silentLogger: Logger;
+//#endregion
+//#region src/core/kit-events.d.ts
+/** `support.*`: support sessions, where a platform admin views the app as a user. */
+interface SupportEventData {
+  /** Absent on `support.denied`. */
+  readonly sessionId?: string;
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly reason?: string;
+  readonly readOnly?: boolean;
+  readonly expiresAt?: Temporal.Instant;
+  /** `support.denied`: which check refused it. */
+  readonly denial?: "authorize" | "permission" | "policy" | "store";
+  /** `support.ended`: who or what ended it. */
+  readonly endedBy?: "admin" | "expired" | "revoked";
+}
+/** `org.*`: organizations and their members. */
+interface OrgEventData {
+  readonly organizationId: string;
+  /** The member the event is about. */
+  readonly userId?: string;
+  readonly role?: string;
+  readonly previousRole?: string;
+}
+/** `invitation.*`. The token is never part of the event. */
+interface InvitationEventData {
+  readonly invitationId: string;
+  /** Absent for a platform-scope invitation. */
+  readonly organizationId?: string;
+  readonly email?: string;
+  readonly role?: string;
+}
+/** `notification.*`. */
+interface NotificationEventData {
+  readonly notificationId: string;
+  readonly type: string;
+  readonly recipientIds?: readonly string[];
+  readonly channel?: string;
+  readonly error?: string;
+}
+/** `webhook.*`: outgoing webhooks. */
+interface WebhookEventData {
+  readonly endpointId: string;
+  readonly deliveryId?: string;
+  readonly eventType?: string;
+  /** The HTTP status of the attempt, when there was a response. */
+  readonly status?: number;
+  readonly attempt?: number;
+  readonly error?: string;
+}
+/** Every kit event type and its data. */
+interface KitEventMap {
+  "support.started": SupportEventData;
+  "support.ended": SupportEventData;
+  "support.denied": SupportEventData;
+  "org.created": OrgEventData;
+  "org.updated": OrgEventData;
+  "org.deleted": OrgEventData;
+  "org.member_added": OrgEventData;
+  "org.member_removed": OrgEventData;
+  "org.member_left": OrgEventData;
+  "org.role_changed": OrgEventData;
+  "org.ownership_transferred": OrgEventData;
+  "org.switched": OrgEventData;
+  "invitation.created": InvitationEventData;
+  "invitation.resent": InvitationEventData;
+  "invitation.accepted": InvitationEventData;
+  "invitation.declined": InvitationEventData;
+  "invitation.revoked": InvitationEventData;
+  "notification.created": NotificationEventData;
+  "notification.delivered": NotificationEventData;
+  "notification.failed": NotificationEventData;
+  "webhook.delivered": WebhookEventData;
+  "webhook.failed": WebhookEventData;
+  "webhook.disabled": WebhookEventData;
+}
+type KitEventType = keyof KitEventMap;
+/** Where an event came from, beyond its data. */
+interface KitEventMeta {
+  /** e.g. `organizations/<id>`; becomes the CloudEvents `subject`. */
+  readonly subject?: string;
+  readonly tenant?: string;
+  /** The user who caused it. */
+  readonly actorId?: string;
+  readonly context?: RequestContext;
+}
+/** A kit event as `betterSupabase.on('kit', handler)` receives it. */
+type KitEvent<K extends KitEventType = KitEventType> = { readonly [T in K]: KitEventMeta & {
+  readonly type: T;
+  /** A copy: changing it never changes what the kit does (invariant 5). */
+  readonly data: KitEventMap[T];
+  readonly time: Temporal.Instant;
+}; }[K];
+/** A type, or a `prefix.*` pattern such as `support.*`. */
+type KitEventPattern = KitEventType | `${KitEventType extends `${infer P}.${string}` ? P : never}.*`;
+/** The event types a pattern matches. */
+type KitEventsMatching<P extends KitEventPattern> = P extends `${infer Prefix}.*` ? Extract<KitEventType, `${Prefix}.${string}`> : Extract<P, KitEventType>;
+/**
+ * Fixed OpenTelemetry attribute names for kit work, so dashboards and
+ * queries can rely on them.
+ */
+declare const KIT_ATTRIBUTES: {
+  readonly event: "better_supabase.kit.event";
+  readonly tenant: "better_supabase.tenant";
+  readonly actor: "better_supabase.actor.id";
+  readonly supportSessionId: "better_supabase.support.session_id";
+  readonly orgId: "better_supabase.org.id";
+  readonly invitationId: "better_supabase.invitation.id";
+  readonly notificationType: "better_supabase.notification.type";
+  readonly webhookEndpointId: "better_supabase.webhook.endpoint_id";
+};
+/** The `KIT_ATTRIBUTES` an event carries. */
+declare function kitEventAttributes(event: KitEvent): Record<string, string>;
+/**
+ * Listens to the kit events that match `pattern` (`'support.started'` or
+ * `'support.*'`). Returns a function that stops listening.
+ */
+declare function onKitEvent<P extends KitEventPattern>(betterSupabase: {
+  readonly events: EventHub;
+}, pattern: P, handler: (event: KitEvent<KitEventsMatching<P>>) => void): () => void;
+//#endregion
+//#region src/core/events.d.ts
+interface QueryEvent {
+  readonly table: string;
+  readonly operation: Operation["kind"];
+  readonly ok: boolean;
+  readonly durationMs: number;
+  readonly rows: number;
+  /**
+   * An unbounded read returned `maxRows` rows: PostgREST's `db-max-rows`
+   * probably cut it short. Add `limit` or use `paginate`.
+   */
+  readonly truncated: boolean;
+}
+interface MutationNotice {
+  readonly table: string;
+  readonly kind: MutationKind;
+  /** See `MutationEvent.intent`. */
+  readonly intent?: MutationIntent;
+  /** A copy of the returned rows: changing it never changes the result. */
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  /** See `MutationEvent.keys`. */
+  readonly keys?: readonly Readonly<Record<string, unknown>>[];
+  /** See `MutationEvent.tenant`. */
+  readonly tenant?: string;
+  readonly context: RequestContext;
+}
+/** A successful RPC registered with `betterSupabase.defineRpc(name, { invalidates })`. */
+interface RpcNotice {
+  readonly name: string;
+  /** App keys of the tables the function changes. */
+  readonly invalidates: readonly string[];
+  readonly context: RequestContext;
+}
+interface ErrorEvent {
+  readonly table?: string;
+  readonly error: DbError;
+}
+interface AuthEvent {
+  readonly source: "bearer" | "cookie" | "none";
+  readonly ok: boolean;
+  readonly userId?: string;
+  /**
+   * Why there is no user: the anon reason (`expired`, `signed_out`, ...) or
+   * the invalid reason (`token`, `claims`, `actor`).
+   */
+  readonly reason?: "none" | "expired" | "signed_out" | "refresh_failed" | "token" | "claims" | "actor";
+  /** The user's `source` as the resolver set it, e.g. a custom resolver's name. */
+  readonly rawSource?: string;
+}
+interface RefreshEvent {
+  readonly ok: boolean;
+  readonly shared: boolean;
+  readonly durationMs: number;
+}
+interface BetterSupabaseEvents {
+  query: QueryEvent;
+  mutation: MutationNotice;
+  rpc: RpcNotice;
+  error: ErrorEvent;
+  auth: AuthEvent;
+  refresh: RefreshEvent;
+  /** Support sessions, organizations, invitations, notifications and webhooks. */
+  kit: KitEvent;
+}
+type EventName = keyof BetterSupabaseEvents;
+type EventHandler<K extends EventName> = (event: BetterSupabaseEvents[K]) => void;
+/**
+ * Observers only: a handler that throws is reported to the logger and never
+ * changes a result.
+ */
+declare class EventHub {
+  #private;
+  readonly logger: Logger;
+  constructor(logger?: Logger);
+  on<K extends EventName>(name: K, handler: EventHandler<K>): () => void;
+  has(name: EventName): boolean;
+  /**
+   * Keeps async work a handler started (a sink send) until it settles, so
+   * adapters can hand it to `after()` or `waitUntil`. Its outcome is ignored:
+   * handlers report their own failures.
+   */
+  track(work: PromiseLike<unknown>): void;
+  /** Whether tracked work is still running. */
+  get pending(): boolean;
+  /** Resolves once the work tracked so far has settled. Never rejects. */
+  settled(): Promise<void>;
+  emit<K extends EventName>(name: K, event: BetterSupabaseEvents[K]): void;
+}
+//#endregion
+export { kitEventAttributes as C, consoleLogger as D, Logger as E, silentLogger as O, WebhookEventData as S, LogFields as T, KitEventType as _, EventHub as a, OrgEventData as b, QueryEvent as c, InvitationEventData as d, KIT_ATTRIBUTES as f, KitEventPattern as g, KitEventMeta as h, EventHandler as i, RefreshEvent as l, KitEventMap as m, BetterSupabaseEvents as n, EventName as o, KitEvent as p, ErrorEvent as r, MutationNotice as s, AuthEvent as t, RpcNotice as u, KitEventsMatching as v, onKitEvent as w, SupportEventData as x, NotificationEventData as y };