better-supabase 0.5.1 → 0.6.0

package/dist/notifications/index.js

@@ -1,264 +0,0 @@
-import { c as mapDbError, n as dbError } from "../errors-DtwXa6b8.js";
-import { t as temporal } from "../temporal-required-CAt4Dc9Z.js";
-import { i as ok, n as err, o as toDbError, t as AsyncResult } from "../result-BKiliPY7.js";
-import { t as validate } from "../standard-D7r6dMUu.js";
-import { n as emitKitEvent } from "../kit-events-CTFDfSwb.js";
-import { n as rpcTransport, r as sqlTransport, t as rawError } from "../kit-transport-DJlHQUBU.js";
-//#region src/notifications/notifications.ts
-const DEFAULT_SCHEMA = "better_supabase";
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const textOf = (value) => value === null || value === void 0 ? null : String(value);
-const instantOf = (value) => typeof value === "string" ? temporal().Instant.from(value) : null;
-function toItem(row) {
-	const type = textOf(row["subject_type"]);
-	const id = textOf(row["subject_id"]);
-	const label = textOf(row["subject_label"]);
-	return {
-		id: String(row["id"]),
-		eventId: String(row["event_id"]),
-		type: String(row["type"]),
-		data: row["data"] ?? {},
-		tenant: textOf(row["tenant"]),
-		actorId: textOf(row["actor_id"]),
-		subject: type === null || id === null ? null : {
-			type,
-			id,
-			...label === null ? {} : { label }
-		},
-		summary: textOf(row["summary"]),
-		actionPath: textOf(row["action_path"]),
-		priority: textOf(row["priority"]),
-		createdAt: instantOf(row["created_at"]) ?? temporal().Now.instant(),
-		readAt: instantOf(row["read_at"]),
-		resolvedAt: instantOf(row["resolved_at"])
-	};
-}
-function cursorOf(before) {
-	if (before === void 0) return {
-		before: null,
-		before_id: null
-	};
-	if ("epochNanoseconds" in before) return {
-		before: before.toString(),
-		before_id: null
-	};
-	return {
-		before: before.createdAt.toString(),
-		before_id: before.id
-	};
-}
-const errorText = (cause) => cause instanceof Error ? cause.message : String(cause);
-function createNotifications(options) {
-	const { transport } = options;
-	const schema = options.schema ?? DEFAULT_SCHEMA;
-	const mappers = options.errorMappers ?? [];
-	const call = async (fn, args) => transport.call(schema, fn, args);
-	function run(fn, args, then) {
-		return AsyncResult.from(async () => {
-			let value;
-			try {
-				value = await call(fn, args);
-			} catch (cause) {
-				const raw = rawError(cause);
-				return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
-			}
-			return ok(await then(value));
-		});
-	}
-	function emit(type, data, tenant) {
-		if (!options.events) return;
-		emitKitEvent(options.events, type, data, {
-			subject: `notifications/${data.notificationId}`,
-			...tenant ? { tenant } : {},
-			...options.actorId ? { actorId: options.actorId } : {},
-			...options.context ? { context: options.context } : {}
-		});
-	}
-	const render = (item, locale) => {
-		if (!options.render) return item;
-		return {
-			...item,
-			text: options.render(item, locale === void 0 ? {} : { locale })
-		};
-	};
-	async function deliverOne(channel, row, maxAttempts) {
-		const notification = isRecord(row["notification"]) ? toItem(row["notification"]) : void 0;
-		if (!notification) throw new TypeError("claim returned no notification");
-		const attempts = Number(row["attempts"] ?? 1);
-		const message = {
-			deliveryId: String(row["delivery_id"]),
-			channel: channel.name,
-			attempts,
-			userId: String(row["user_id"]),
-			email: textOf(row["email"]),
-			notification,
-			...options.render ? { text: options.render(notification, {}) } : {}
-		};
-		try {
-			const result = await channel.send(message);
-			const status = result?.status ?? "sent";
-			await call("complete_notification_delivery", {
-				delivery: message.deliveryId,
-				status,
-				provider: result?.provider ?? null,
-				provider_message_id: result?.providerMessageId ?? null
-			});
-			if (status === "sent") emit("notification.delivered", {
-				notificationId: notification.eventId,
-				type: notification.type,
-				channel: channel.name
-			}, notification.tenant);
-			return status;
-		} catch (cause) {
-			const error = errorText(cause);
-			await call("complete_notification_delivery", {
-				delivery: message.deliveryId,
-				status: "pending",
-				error,
-				max_attempts: maxAttempts
-			});
-			emit("notification.failed", {
-				notificationId: notification.eventId,
-				type: notification.type,
-				channel: channel.name,
-				error
-			}, notification.tenant);
-			return "failed";
-		}
-	}
-	return {
-		send(type, input) {
-			return AsyncResult.from(async () => {
-				const schemaOf = Object.hasOwn(options.types, type) ? options.types[type] : void 0;
-				if (schemaOf === void 0) return err(dbError("validation", `Unknown notification type "${type}"`, {
-					issues: [{
-						path: ["type"],
-						message: `Unknown type "${type}"`
-					}],
-					hint: "NOTIFICATION_TYPE_UNKNOWN"
-				}));
-				const data = await validate(schemaOf, input.data, `${type} data`);
-				if (!data.ok) return err(data.error);
-				const sent = await run("notify", { notification: {
-					type,
-					data: data.data,
-					recipients: input.recipients ?? [],
-					tenant: input.tenant,
-					subject_type: input.subject?.type,
-					subject_id: input.subject?.id,
-					subject_label: input.subject?.label,
-					summary: input.summary,
-					action_path: input.actionPath,
-					priority: input.priority,
-					key: input.key,
-					channels: input.channels,
-					include_actor: input.includeActor,
-					activity: input.activity,
-					resolved: input.resolved,
-					actor: input.actorId
-				} }, (value) => value === null ? null : String(value));
-				if (!sent.ok || sent.data === null) return sent;
-				const recipients = input.recipients ?? [];
-				emit("notification.created", {
-					notificationId: sent.data,
-					type,
-					recipientIds: recipients
-				}, input.tenant ?? null);
-				if (options.onSent) try {
-					await options.onSent({
-						id: sent.data,
-						type,
-						tenant: input.tenant ?? null,
-						recipients
-					});
-				} catch (cause) {
-					return err(toDbError(cause));
-				}
-				return sent;
-			});
-		},
-		list(listOptions = {}) {
-			return run("list_notifications", {
-				tenant: listOptions.tenant ?? null,
-				status: listOptions.status ?? "all",
-				types: listOptions.types ?? null,
-				...cursorOf(listOptions.before),
-				max_items: listOptions.limit ?? 50
-			}, (value) => (Array.isArray(value) ? value : []).filter(isRecord).map((row) => render(toItem(row), listOptions.locale)));
-		},
-		counts(countOptions = {}) {
-			return run("notification_counts", {
-				tenant: countOptions.tenant ?? null,
-				actionable: options.actionable ?? []
-			}, (value) => ({
-				unread: Number(isRecord(value) ? value["unread"] ?? 0 : 0),
-				actionable: Number(isRecord(value) ? value["actionable"] ?? 0 : 0)
-			}));
-		},
-		markRead(readOptions = {}) {
-			return run("mark_notifications_read", {
-				ids: readOptions.ids ?? null,
-				tenant: readOptions.tenant ?? null
-			}, Number);
-		},
-		dismiss(ids) {
-			return run("dismiss_notifications", { ids }, Number);
-		},
-		resolve(input) {
-			return run("resolve_notifications", {
-				type: input.type,
-				subject_type: input.subject.type,
-				subject_id: input.subject.id,
-				tenant: input.tenant ?? null
-			}, Number);
-		},
-		subscribe(input) {
-			return run("set_notification_subscription", {
-				subject_type: input.subject.type,
-				subject_id: input.subject.id,
-				level: input.level,
-				tenant: input.tenant ?? null,
-				member: input.userId ?? null
-			}, () => void 0);
-		},
-		setPreference(input) {
-			return run("set_notification_preference", {
-				type: input.type,
-				channel: input.channel,
-				enabled: input.enabled,
-				tenant: input.tenant ?? null
-			}, () => void 0);
-		},
-		async deliver(deliverOptions = {}) {
-			const wanted = deliverOptions.channels;
-			const channels = (options.channels ?? []).filter((channel) => !wanted || wanted.includes(channel.name));
-			const deadline = deliverOptions.budgetMs === void 0 ? Number.POSITIVE_INFINITY : Date.now() + deliverOptions.budgetMs;
-			const batch = deliverOptions.batch ?? 50;
-			const counts = {
-				sent: 0,
-				skipped: 0,
-				failed: 0
-			};
-			for (const channel of channels) while (Date.now() < deadline) {
-				const claimed = await call("claim_notification_deliveries", {
-					channel: channel.name,
-					max_items: batch,
-					lease: deliverOptions.lease ?? "5 minutes",
-					max_attempts: deliverOptions.maxAttempts ?? 5
-				});
-				const rows = (Array.isArray(claimed) ? claimed : []).filter(isRecord);
-				for (const row of rows) counts[await deliverOne(channel, row, deliverOptions.maxAttempts ?? 5)] += 1;
-				if (rows.length < batch) break;
-			}
-			return counts;
-		},
-		purge(olderThan, batch) {
-			return run("purge_notifications", {
-				older_than: olderThan ?? null,
-				batch: batch ?? null
-			}, Number);
-		}
-	};
-}
-//#endregion
-export { createNotifications, rpcTransport, sqlTransport };

package/dist/orgs/index.d.ts

@@ -1,132 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { S as ErrorMapper, a as AsyncResult } from "../executor-BunPOO-k.js";
-import { a as EventHub } from "../events-aIO7vsIk.js";
-import { g as RequestContext } from "../plugin-o144f322.js";
-import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as KitTransport } from "../kit-transport-B82k1djG.js";
-//#region src/orgs/orgs.d.ts
-/**
- * Organization columns by database name: `name`, `slug` and the columns in
- * `kits.organizations.options.attributes`. Other keys are ignored.
- */
-interface OrgAttributes {
-  readonly name?: string;
-  readonly slug?: string;
-  readonly [column: string]: unknown;
-}
-interface CreateOrgOptions {
-  /** The owner, when the transport runs as the service role. */
-  readonly ownerId?: string;
-}
-type SlugProblem = "invalid" | "reserved" | "taken";
-interface InviteRequest {
-  /** `null` invites to the platform (`kits.access.model: 'catalog'`). */
-  readonly organizationId: string | null;
-  readonly email: string;
-  /** A role name, or a role id or key under the catalog model. */
-  readonly role: string;
-  /** A Postgres interval such as `'3 days'`. Defaults to `options.validFor`. */
-  readonly validFor?: string;
-  /** Profile fields to fill in on sign-up. */
-  readonly prefill?: Readonly<Record<string, unknown>>;
-}
-interface Invitation {
-  readonly id: string;
-  readonly organizationId: string | null;
-  readonly email: string;
-  readonly role: string;
-  readonly expiresAt: Temporal.Instant;
-  readonly invitedBy?: string;
-  readonly prefill: Readonly<Record<string, unknown>>;
-}
-/** What `onInvite` receives: the place to send the email. */
-interface InvitationSent {
-  readonly invitation: Invitation;
-  /** Put it in the accept link. It is never stored in plain text by default. */
-  readonly token: string;
-  readonly resent: boolean;
-}
-type InvitationStatus = "pending" | "accepted" | "declined" | "revoked" | "expired";
-interface InvitationPreview {
-  readonly status: InvitationStatus;
-  readonly email: string;
-  readonly role: string;
-  readonly organizationId: string | null;
-  readonly expiresAt: Temporal.Instant;
-  /** The organization columns in `options.previewColumns`. */
-  readonly organization: Readonly<Record<string, unknown>> | null;
-  readonly prefill: Readonly<Record<string, unknown>>;
-}
-interface SwitchResult {
-  readonly organizationId: string;
-  /** The active tenant is a claim: refresh the session to get it. */
-  readonly refresh: boolean;
-}
-interface OrgsOptions {
-  /** `sqlTransport(postgres.asUser(claims))` or `rpcTransport(supabase)`. */
-  readonly transport: KitTransport;
-  /**
-   * The schema holding the functions: `kits.<module>.schema` with
-   * `sqlTransport`, the exposed API schema of wrappers with `rpcTransport`.
-   * One schema for both modules, or one per module. Defaults to
-   * `better_supabase`.
-   */
-  readonly schema?: string | {
-    readonly organizations?: string;
-    readonly invitations?: string;
-  };
-  /** `betterSupabase.events`, to emit `org.*` and `invitation.*` kit events. */
-  readonly events?: EventHub;
-  /** The user acting, for event metadata. */
-  readonly actorId?: string;
-  readonly context?: RequestContext;
-  /**
-   * Runs before an invitation is created, after the database checks the
-   * caller may invite. Return `false` to refuse (seat limits, plans).
-   */
-  readonly canInvite?: (request: InviteRequest) => boolean | Promise<boolean>;
-  /**
-   * Runs after an invitation is created or resent, to send the email. When
-   * it throws, the call returns an error and the invitation stays open:
-   * call `resendInvitation` to retry.
-   */
-  readonly onInvite?: (sent: InvitationSent) => void | Promise<void>;
-  /** Run before the built-in mapping, as in `betterSupabase.mapError()`. */
-  readonly errorMappers?: readonly ErrorMapper[];
-}
-/**
- * The `organizations` and `invitations` SQL kit modules as typed calls. Each
- * method returns an `AsyncResult`; database errors carry the kit's error
- * code (`ORG_FORBIDDEN`, `INVITATION_INVALID`) as `hint`.
- */
-interface Orgs {
-  create(attributes: OrgAttributes, options?: CreateOrgOptions): AsyncResult<{
-    readonly id: string;
-  }>;
-  update(organizationId: string, attributes: OrgAttributes): AsyncResult<true>;
-  /** `false` when it did not exist (or was already soft-deleted). */
-  delete(organizationId: string): AsyncResult<boolean>;
-  /** Why a slug can't be used, or `undefined` when it can. */
-  slugProblem(slug: string, exceptOrganizationId?: string): AsyncResult<SlugProblem | undefined>;
-  updateMemberRole(organizationId: string, userId: string, role: string): AsyncResult<true>;
-  removeMember(organizationId: string, userId: string): AsyncResult<true>;
-  leave(organizationId: string): AsyncResult<true>;
-  /** `formerRole` defaults to `options.formerOwnerRole`. */
-  transferOwnership(organizationId: string, newOwnerId: string, formerRole?: string): AsyncResult<true>;
-  markUsed(organizationId: string): AsyncResult<boolean>;
-  switch(organizationId: string): AsyncResult<SwitchResult>;
-  invite(request: InviteRequest): AsyncResult<InvitationSent>;
-  resendInvitation(invitationId: string, validFor?: string): AsyncResult<InvitationSent>;
-  /** `false` when it was not open. */
-  revokeInvitation(invitationId: string): AsyncResult<boolean>;
-  declineInvitation(token: string): AsyncResult<boolean>;
-  /** `undefined` for an unknown token. Callable without a session. */
-  previewInvitation(token: string): AsyncResult<InvitationPreview | undefined>;
-  /** Returns the organization joined, `null` for a platform invitation. */
-  acceptInvitation(token: string): AsyncResult<{
-    readonly organizationId: string | null;
-  }>;
-}
-/** Calls the `organizations` and `invitations` kit functions. */
-export declare function createOrgs(options: OrgsOptions): Orgs;
-//#endregion
-export { type CreateOrgOptions, type Invitation, type InvitationPreview, type InvitationSent, type InvitationStatus, type InviteRequest, type KitTransport, type OrgAttributes, type Orgs, type OrgsOptions, type RpcClient, type SlugProblem, type SwitchResult, rpcTransport, sqlTransport };

package/dist/orgs/index.js

@@ -1,245 +0,0 @@
-import { c as mapDbError, n as dbError } from "../errors-DtwXa6b8.js";
-import { t as temporal } from "../temporal-required-CAt4Dc9Z.js";
-import { i as ok, n as err, o as toDbError, t as AsyncResult } from "../result-BKiliPY7.js";
-import { n as emitKitEvent } from "../kit-events-CTFDfSwb.js";
-import { n as rpcTransport, r as sqlTransport, t as rawError } from "../kit-transport-DJlHQUBU.js";
-//#region src/orgs/orgs.ts
-const DEFAULT_SCHEMA = "better_supabase";
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const text = (value) => typeof value === "string" ? value : String(value);
-const optionalText = (value) => value === null || value === void 0 ? null : text(value);
-function invitationFrom(row) {
-	const invitedBy = optionalText(row["invited_by"]);
-	return {
-		id: text(row["id"]),
-		organizationId: optionalText(row["tenant"]),
-		email: text(row["email"]),
-		role: text(row["role"]),
-		expiresAt: temporal().Instant.from(text(row["expires_at"])),
-		...invitedBy === null ? {} : { invitedBy },
-		prefill: isRecord(row["prefill"]) ? row["prefill"] : {}
-	};
-}
-const STATUSES = /* @__PURE__ */ new Set([
-	"pending",
-	"accepted",
-	"declined",
-	"revoked",
-	"expired"
-]);
-function isStatus(value) {
-	return typeof value === "string" && STATUSES.has(value);
-}
-function previewFrom(row) {
-	const status = row["status"];
-	if (!isStatus(status)) throw new TypeError(`Unknown invitation status ${String(status)}`);
-	return {
-		status,
-		email: text(row["email"]),
-		role: text(row["role"]),
-		organizationId: optionalText(row["tenant"]),
-		expiresAt: temporal().Instant.from(text(row["expires_at"])),
-		organization: isRecord(row["organization"]) ? row["organization"] : null,
-		prefill: isRecord(row["prefill"]) ? row["prefill"] : {}
-	};
-}
-function recordOf(value, fn) {
-	if (!isRecord(value)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
-	return value;
-}
-/** Calls the `organizations` and `invitations` kit functions. */
-function createOrgs(options) {
-	const { transport } = options;
-	const schemaOf = (module) => typeof options.schema === "string" ? options.schema : options.schema?.[module] ?? DEFAULT_SCHEMA;
-	const mappers = options.errorMappers ?? [];
-	function run(module, fn, args, then) {
-		return AsyncResult.from(async () => {
-			let value;
-			try {
-				value = await transport.call(schemaOf(module), fn, args);
-			} catch (cause) {
-				const raw = rawError(cause);
-				return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
-			}
-			return ok(await then(value));
-		});
-	}
-	function emit(type, data, subject, tenant) {
-		if (!options.events) return;
-		emitKitEvent(options.events, type, data, {
-			subject,
-			...tenant ? { tenant } : {},
-			...options.actorId ? { actorId: options.actorId } : {},
-			...options.context ? { context: options.context } : {}
-		});
-	}
-	const orgEvent = (type, data) => {
-		emit(type, data, `organizations/${data.organizationId}`, data.organizationId);
-	};
-	const invitationEvent = (type, data) => {
-		emit(type, data, `invitations/${data.invitationId}`, data.organizationId ?? null);
-	};
-	const sent = async (value, fn, resent) => {
-		const row = recordOf(value, fn);
-		const invitation = invitationFrom(row);
-		const result = {
-			invitation,
-			token: text(row["token"]),
-			resent
-		};
-		invitationEvent(resent ? "invitation.resent" : "invitation.created", {
-			invitationId: invitation.id,
-			...invitation.organizationId === null ? {} : { organizationId: invitation.organizationId },
-			email: invitation.email,
-			role: invitation.role
-		});
-		await options.onInvite?.(result);
-		return result;
-	};
-	return {
-		create(attributes, createOptions) {
-			return run("organizations", "create_organization", { attrs: {
-				...attributes,
-				...createOptions?.ownerId ? { owner_id: createOptions.ownerId } : {}
-			} }, (value) => {
-				const id = text(value);
-				orgEvent("org.created", {
-					organizationId: id,
-					...createOptions?.ownerId ?? options.actorId ? { userId: createOptions?.ownerId ?? options.actorId } : {}
-				});
-				return { id };
-			});
-		},
-		update(organizationId, attributes) {
-			return run("organizations", "update_organization", {
-				org: organizationId,
-				attrs: attributes
-			}, () => {
-				orgEvent("org.updated", { organizationId });
-				return true;
-			});
-		},
-		delete(organizationId) {
-			return run("organizations", "delete_organization", { org: organizationId }, (value) => {
-				if (value === true) orgEvent("org.deleted", { organizationId });
-				return value === true;
-			});
-		},
-		slugProblem(slug, exceptOrganizationId) {
-			return run("organizations", "organization_slug_problem", {
-				value: slug,
-				except_org: exceptOrganizationId
-			}, (value) => {
-				if (value === null) return;
-				if (value === "invalid" || value === "reserved" || value === "taken") return value;
-				throw new TypeError(`Unknown slug problem ${String(value)}`);
-			});
-		},
-		updateMemberRole(organizationId, userId, role) {
-			return run("organizations", "update_member_role", {
-				org: organizationId,
-				member: userId,
-				role
-			}, () => {
-				orgEvent("org.role_changed", {
-					organizationId,
-					userId,
-					role
-				});
-				return true;
-			});
-		},
-		removeMember(organizationId, userId) {
-			return run("organizations", "remove_member", {
-				org: organizationId,
-				member: userId
-			}, () => {
-				orgEvent("org.member_removed", {
-					organizationId,
-					userId
-				});
-				return true;
-			});
-		},
-		leave(organizationId) {
-			return run("organizations", "leave_organization", { org: organizationId }, () => {
-				orgEvent("org.member_left", {
-					organizationId,
-					...options.actorId ? { userId: options.actorId } : {}
-				});
-				return true;
-			});
-		},
-		transferOwnership(organizationId, newOwnerId, formerRole) {
-			return run("organizations", "transfer_ownership", {
-				org: organizationId,
-				new_owner: newOwnerId,
-				former_role: formerRole
-			}, () => {
-				orgEvent("org.ownership_transferred", {
-					organizationId,
-					userId: newOwnerId
-				});
-				return true;
-			});
-		},
-		markUsed(organizationId) {
-			return run("organizations", "mark_used", { org: organizationId }, (value) => value === true);
-		},
-		switch(organizationId) {
-			return run("organizations", "switch_organization", { org: organizationId }, (value) => {
-				const row = recordOf(value, "switch_organization");
-				orgEvent("org.switched", {
-					organizationId,
-					...options.actorId ? { userId: options.actorId } : {}
-				});
-				return {
-					organizationId: text(row["organization_id"]),
-					refresh: row["refresh"] === true
-				};
-			});
-		},
-		invite(request) {
-			return AsyncResult.from(async () => {
-				if (options.canInvite && !await options.canInvite(request)) return err(dbError("forbidden", "The invitation was refused", { hint: "INVITATION_FORBIDDEN" }));
-				return run("invitations", "invite_member", {
-					tenant: request.organizationId,
-					invitee_email: request.email,
-					invitee_role: request.role,
-					valid_for: request.validFor,
-					prefill: request.prefill
-				}, (value) => sent(value, "invite_member", false));
-			});
-		},
-		resendInvitation(invitationId, validFor) {
-			return run("invitations", "resend_invitation", {
-				invitation_id: invitationId,
-				valid_for: validFor
-			}, (value) => sent(value, "resend_invitation", true));
-		},
-		revokeInvitation(invitationId) {
-			return run("invitations", "revoke_invitation", { invitation_id: invitationId }, (value) => {
-				if (value === true) invitationEvent("invitation.revoked", { invitationId });
-				return value === true;
-			});
-		},
-		declineInvitation(token) {
-			return run("invitations", "decline_invitation", { token }, (value) => value === true);
-		},
-		previewInvitation(token) {
-			return run("invitations", "invitation_preview", { token }, (value) => value === null ? void 0 : previewFrom(recordOf(value, "invitation_preview")));
-		},
-		acceptInvitation(token) {
-			return run("invitations", "accept_invitation", { token }, (value) => {
-				const organizationId = optionalText(value);
-				if (organizationId !== null) orgEvent("org.member_added", {
-					organizationId,
-					...options.actorId ? { userId: options.actorId } : {}
-				});
-				return { organizationId };
-			});
-		}
-	};
-}
-//#endregion
-export { createOrgs, rpcTransport, sqlTransport };

package/dist/permdock-sql-C2Inc6Xc.d.ts

@@ -1,29 +0,0 @@
-//#region src/core/permdock-sql.d.ts
-/** PermDock's default `rls.schema`, a schema the Data API does not expose. */
-declare const PERMDOCK_SCHEMA = "permdock";
-/**
- * The part of PermDock's `permissions.catalog.json` the Storage and Realtime
- * builders read: `import catalog from './permissions.catalog.json'`.
- */
-interface PermdockCatalog {
-  readonly permissions: readonly {
-    readonly key: string;
-    readonly rowConditions?: boolean;
-    /** The scope PermDock declares the permission at. */
-    readonly scope?: string;
-  }[];
-}
-/**
- * What PermDock's catalog says about a key: `scope-only` (`rowConditions:
- * false`), `row-conditions` (`true`), `no-flag` (an entry without a boolean
- * flag, from an older `permdock catalog`) or `missing`. Only `scope-only` is
- * safe for the SQL helpers.
- */
-type PermdockKeyStatus = "scope-only" | "row-conditions" | "no-flag" | "missing";
-declare function permdockKeyStatus(catalog: PermdockCatalog, key: string): PermdockKeyStatus;
-/** The keys a bucket or topic PermDock policy names. */
-declare function permdockKeys(policy: {
-  readonly permdock: object;
-}): string[];
-//#endregion
-export { permdockKeys as a, permdockKeyStatus as i, PermdockCatalog as n, PermdockKeyStatus as r, PERMDOCK_SCHEMA as t };