better-supabase 0.8.0 → 0.9.0

package/dist/modules-DpPwzC7E.d.ts

@@ -1,192 +0,0 @@
-//#region src/config/modules.d.ts
-/**
- * `sql.modules` in `better-supabase.config.ts`: how each SQL module maps onto
- * the app's database. A module's contract (the functions other modules and
- * the TypeScript side call) stays the same in every mode; only the tables
- * behind it change.
- */
-/**
- * `managed`: the module owns its tables. `adopt`: the module writes its functions
- * and views over tables the app already has (`tables` and `columns`), never
- * `create table`. `custom`: the app implements the contract functions itself;
- * the module writes nothing and doctor checks the signatures (BS307).
- */
-type ModuleMode = "managed" | "adopt" | "custom";
-/** Options every module takes. */
-interface ModuleConfig {
-  readonly mode?: ModuleMode;
-  /** Schema of the module's functions and managed tables. Defaults to `better_supabase`. */
-  readonly schema?: string;
-  /**
-   * Logical table to `table` or `schema.table`, e.g.
-   * `{ memberships: 'public.organization_users' }`. An unqualified name is in
-   * `schema`. `null` marks an optional table the app doesn't have.
-   */
-  readonly tables?: Readonly<Record<string, string | null>>;
-  /**
-   * Logical table to logical column to column name, e.g.
-   * `{ memberships: { tenant: 'organization_id', role: 'role_id' } }`.
-   * `null` marks an optional column the adopted table doesn't have.
-   */
-  readonly columns?: Readonly<Record<string, Readonly<Record<string, string | null>>>>;
-  /** Type of tenant ids: `uuid` (default), `text`, `bigint` or `integer`. */
-  readonly idType?: string;
-  /**
-   * Module action to permission key, checked through the access contract, e.g.
-   * `{ invite: 'organization.members.invite' }`.
-   */
-  readonly permissions?: Readonly<Record<string, string>>;
-  /** Module-specific options; each module's docs page lists them. */
-  readonly options?: Readonly<Record<string, unknown>>;
-  /**
-   * The app's optional `before_*` and `after_*` functions the module calls
-   * when they exist, e.g. `after_organization_create(organization, user)`. They are
-   * looked up in `schema` (default `public`); `functions` maps a hook name
-   * to another function, e.g. `{ after_organization_create: 'app.seed_organization' }`.
-   */
-  readonly hooks?: {
-    readonly schema?: string;
-    readonly functions?: Readonly<Record<string, string>>;
-  };
-  /**
-   * Whether the module writes its events to the outbox (`emit_event`) when
-   * the `outbox` module is installed. Defaults to true.
-   */
-  readonly events?: boolean;
-  /**
-   * Whether the module writes its actions to the audit log (`audit_event`)
-   * when the `audit` module is installed. Defaults to true.
-   */
-  readonly audit?: boolean;
-  /**
-   * A schema for the Data API, such as `api`: the module writes a
-   * `security invoker` wrapper there for each of its functions that `anon`
-   * or `authenticated` may execute (or only those in `functions`), so
-   * `rpcTransport(supabase, { schema: "api" })` reaches them without
-   * exposing the module schema (doctor BS312).
-   */
-  readonly api?: string | {
-    readonly schema: string;
-    readonly functions?: readonly string[];
-  };
-}
-/**
- * Where the active tenant of a request comes from. Every source counts only
- * while the caller is a member, so a stale claim or setting grants nothing.
- */
-type ActiveTenantSource = "claim" | "resolver" | {
-  readonly profileColumn: string;
-  readonly key?: string;
-};
-/** URL tenancy: the tenant comes from the request (a slug), not a stored setting. */
-declare const DEFAULT_ACTIVE_TENANT: ActiveTenantSource;
-/**
- * The access contract every module checks permissions through:
- * `can(scope, id, permission)`, `tenant_ids_with(permission)`,
- * `is_platform(permission)` and `can_user(user, scope, id, permission)`.
- */
-/**
- * A table whose row says whether a tenant or a user is active. Needs
- * `disabledAt`, `status` with `active`, or both.
- */
-interface DisabledRow {
-  /** `schema.table`. */
-  readonly table: string;
-  /** The column holding the tenant id or the user id. */
-  readonly id: string;
-  /** A nullable timestamp column; a row with a value is disabled. */
-  readonly disabledAt?: string;
-  /** A status column; only a row whose value is in `active` is active. */
-  readonly status?: string;
-  readonly active?: readonly string[];
-}
-interface AccessModuleConfig extends ModuleConfig {
-  /**
-   * `roles`: a fixed role list from `roles` (the default). `catalog`: role,
-   * permission and override tables (`tables.roles`, `permissions`,
-   * `rolePermissions`, `overrides`, `platformAssignments`). `provider`: the
-   * functions of the config's `authorization` provider. `custom`:
-   * expression templates in `functions`.
-   */
-  readonly model?: "roles" | "catalog" | "provider" | "custom";
-  /**
-   * `roles` model: role name to permission keys. `*` grants everything and
-   * `prefix.*` a prefix. Defaults to owner, admin, member and viewer.
-   */
-  readonly roles?: Readonly<Record<string, readonly string[]>>;
-  /**
-   * `custom` model: SQL expressions with `{scope}`, `{id}`, `{permission}`
-   * and `{user}` placeholders, e.g.
-   * `{ can: 'public.authorize_scope({scope}::public.scope_type, {id}, {permission})' }`.
-   */
-  readonly functions?: {
-    readonly can?: string;
-    readonly tenantIdsWith?: string;
-    readonly isPlatform?: string;
-    readonly canUser?: string;
-    /**
-     * `{tenant}` and `{role}`: whether the caller may assign the role.
-     * Required by the `custom` model. The `provider` model defaults to the
-     * provider's `canAssign`; without either, only the service role assigns
-     * roles unless the `tenant` module is installed, and doctor BS411 warns.
-     */
-    readonly canAssign?: string;
-    /**
-     * `{user}`, `{tenant}` and `{role}`: whether that user may assign the
-     * role, for SQL that acts later for a stored user (an invitation accept
-     * checking the inviter again), as `can_assign_as`. The `provider` model
-     * defaults to the provider's `canAssignFor`.
-     */
-    readonly canAssignFor?: string;
-    /** `{user}`: the permission claim for the access token hook. */
-    readonly permissionClaims?: string;
-  };
-  /**
-   * `roles` model: the JWT claim holding the caller's platform permission
-   * keys (an array). Defaults to `platform_permissions`.
-   */
-  readonly platformClaim?: string;
-  /**
-   * What disables a tenant or a user. A string is a column that disables
-   * when set, as `schema.table.column`, keyed by the table's `id` (tenant)
-   * or the column named in `userKey` (user). An object is an active row:
-   * only a row whose `disabledAt` is null and whose `status` is in `active`
-   * is active, and a missing row counts as disabled. Disabled tenants and
-   * users get no permissions. Under the `provider` model both default to the
-   * provider's `suspension`.
-   */
-  readonly disabled?: {
-    readonly tenant?: string | DisabledRow;
-    readonly user?: string | DisabledRow;
-    readonly userKey?: string;
-  };
-  readonly activeTenant?: ActiveTenantSource;
-}
-/** `sql.modules` in the config, keyed by module name. */
-interface ModulesConfig {
-  readonly access?: AccessModuleConfig;
-  /** `AccessModuleConfig` is listed so an `access` literal passes the excess-property check. */
-  readonly [module: string]: ModuleConfig | AccessModuleConfig | undefined;
-}
-/** A module's config with defaults applied. */
-interface ResolvedModule {
-  readonly mode: ModuleMode;
-  readonly schema: string;
-  readonly tables: Readonly<Record<string, string | null>>;
-  readonly columns: Readonly<Record<string, Readonly<Record<string, string | null>>>>;
-  readonly idType?: string;
-  readonly permissions: Readonly<Record<string, string>>;
-  readonly options: Readonly<Record<string, unknown>>;
-  readonly hooks: {
-    readonly schema: string;
-    readonly functions: Readonly<Record<string, string>>;
-  };
-  readonly events: boolean;
-  readonly audit: boolean;
-  readonly api?: {
-    readonly schema: string;
-    readonly functions?: readonly string[];
-  };
-}
-//#endregion
-export { ModuleConfig as a, ResolvedModule as c, DisabledRow as i, ActiveTenantSource as n, ModuleMode as o, DEFAULT_ACTIVE_TENANT as r, ModulesConfig as s, AccessModuleConfig as t };

package/dist/onboarding-LZvlK1P4.d.ts

@@ -1,62 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "./result-BchM1XZn.js";
-import { t as BlockTransport } from "./block-transport-inD4fFq-.js";
-import { r as BlockTemporalOptions } from "./block-helpers-C0Xj8War.js";
-//#region src/blocks/onboarding/onboarding.d.ts
-type ChecklistScope = "user" | "organization";
-/** One step. `events` completes it when the outbox records one of those types. */
-interface ChecklistStep<Id extends string = string> {
-  readonly id: Id;
-  readonly title?: string;
-  readonly description?: string;
-  /** Where the step is done in the app, for a "Start" link. */
-  readonly href?: string;
-  readonly events?: readonly string[];
-}
-interface ChecklistSpec<Id extends string, Scope extends ChecklistScope> {
-  readonly id: string;
-  /** `user` tracks each user; `organization` tracks each tenant. */
-  readonly scope: Scope;
-  readonly steps: readonly ChecklistStep<Id>[];
-}
-interface ChecklistConnectOptions extends BlockTemporalOptions {
-  readonly transport: BlockTransport;
-  /** The module schema (`sql.modules.onboarding.schema`), default `better_supabase`. */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
-}
-/** A step with the subject's progress. */
-interface StepProgress<Id extends string> extends ChecklistStep<Id> {
-  readonly completed: boolean;
-  readonly completedAt: Temporal.Instant | undefined;
-  readonly completedBy: string | undefined;
-}
-interface ChecklistProgress<Id extends string> {
-  readonly steps: readonly StepProgress<Id>[];
-  readonly completed: number;
-  readonly total: number;
-  /** Every step is complete. */
-  readonly done: boolean;
-  /** The first step not done yet. */
-  readonly next: StepProgress<Id> | undefined;
-}
-/** The organization for an organization checklist; nothing for a user one. */
-type ChecklistSubject<Scope extends ChecklistScope> = Scope extends "organization" ? [organizationId: string] : [];
-interface ChecklistClient<Id extends string, Scope extends ChecklistScope> {
-  progress(...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
-  /** Marks a step done; `false` when it already was. */
-  complete(step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
-  /** Marks a step not done; `false` when it wasn't. */
-  reset(step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
-}
-interface Checklist<Id extends string, Scope extends ChecklistScope> extends ChecklistSpec<Id, Scope> {
-  connect(options: ChecklistConnectOptions): ChecklistClient<Id, Scope>;
-}
-/**
- * Declares an onboarding checklist. Pass the result to
- * `sql.modules.onboarding.options.checklists` so the database knows its
- * steps, and `connect` it to read and complete them.
- */
-declare function defineChecklist<const Id extends string, const Scope extends ChecklistScope>(spec: ChecklistSpec<Id, Scope>): Checklist<Id, Scope>;
-//#endregion
-export { ChecklistScope as a, ChecklistSubject as c, ChecklistProgress as i, StepProgress as l, ChecklistClient as n, ChecklistSpec as o, ChecklistConnectOptions as r, ChecklistStep as s, Checklist as t, defineChecklist as u };

package/dist/optional-peer-D1pi-skw.js

@@ -1,24 +0,0 @@
-//#region src/core/optional-peer.ts
-/**
-* Imports an optional peer package on first use, or resolves `undefined` when
-* it is not installed so the caller can say how to add it. The specifier is
-* a variable on purpose: bundlers then leave the peer out of apps that never
-* reach this call.
-*/
-async function importOptionalPeer(specifier) {
-	try {
-		return await import(specifier);
-	} catch {
-		return;
-	}
-}
-/** Runs `load` once and shares the promise. A rejection is not kept, so the next call tries again. */
-function memoized(load) {
-	let promise;
-	return () => promise ??= load().catch((cause) => {
-		promise = void 0;
-		throw cause;
-	});
-}
-//#endregion
-export { memoized as n, importOptionalPeer as t };

package/dist/outbox-DZfAvfzC.d.ts

@@ -1,161 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { b as DbError, t as AsyncResult } from "./result-BchM1XZn.js";
-import { t as SqlClient } from "./executor-ngjKL_Pe.js";
-import { t as BlockTransport } from "./block-transport-inD4fFq-.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-C0Xj8War.js";
-import { t as BlockProblemOptions } from "./problem-TvGdxO1t.js";
-import { i as EventSink, t as CloudEvent } from "./cloud-event-Dune0KI7.js";
-//#region src/blocks/outbox/outbox.d.ts
-/** One row of the outbox, as `outbox_claim` and `outbox_history` return it. */
-interface OutboxEvent {
-  /** The cursor value: increases with every event. */
-  readonly position: number;
-  readonly id: string;
-  readonly type: string;
-  readonly payload: unknown;
-  /** The module or function that wrote it, e.g. `better-supabase/blocks/organizations`. */
-  readonly source: string | null;
-  readonly subject: string | null;
-  readonly tenant: string | null;
-  readonly key: string | null;
-  readonly actorId: string | null;
-  readonly createdAt: Temporal.Instant;
-}
-interface EmitOptions {
-  readonly subject?: string;
-  readonly tenant?: string;
-  /** With a key, emitting again (per tenant) returns the first event. */
-  readonly key?: string;
-  readonly source?: string;
-}
-interface OutboxOptions extends BlockTemporalOptions {
-  /** The schema of the `outbox` module. Defaults to `better_supabase`. */
-  readonly schema?: string;
-  /** CloudEvents `source` of the relayed events, e.g. `https://crm.example.com`. */
-  readonly source: string;
-  /** Prepended to each type with a dot when relaying, e.g. `com.example`. Defaults to `dev.better-supabase`. */
-  readonly typePrefix?: string;
-}
-interface RegisterOptions {
-  /** Type patterns such as `organization.*` or `invoice.paid`. Defaults to every event. */
-  readonly types?: readonly string[];
-  /** Start at the first kept event instead of after the latest one. */
-  readonly fromStart?: boolean;
-}
-interface RelayOptions {
-  /** Events per claim and per `sink.send`. Defaults to 100. */
-  readonly batch?: number;
-  /** How long a claim holds the consumer. Defaults to `1 minute`. */
-  readonly lease?: string;
-  /** Stops claiming after this many milliseconds. */
-  readonly budgetMs?: number;
-  /** Identifies this worker in the lease. Defaults to a random id. */
-  readonly owner?: string;
-  /**
-   * Failures in a row before the event that keeps failing goes to the dead
-   * letters and the cursor moves past it. Defaults to 10.
-   */
-  readonly maxAttempts?: number;
-  /** The longest wait between failed attempts. Defaults to `10 minutes`. */
-  readonly maxBackoff?: string;
-}
-interface RelayResult {
-  readonly delivered: number;
-  /**
-   * Set when the sink threw: the consumer backs off and retries the batch
-   * one event at a time.
-   */
-  readonly error?: DbError;
-  /** 1 when this run moved the failing event to the dead letters. */
-  readonly deadLettered?: number;
-}
-/** An event a consumer skipped after `maxAttempts` failures. */
-interface OutboxDeadLetter {
-  readonly consumer: string;
-  readonly event: OutboxEvent;
-  readonly attempts: number;
-  readonly error: string | null;
-  readonly deadAt: Temporal.Instant;
-}
-interface OutboxPurgeOptions {
-  /**
-   * A consumer that hasn't claimed for this long (a Postgres interval such
-   * as `30 days`) no longer holds events back. Defaults to waiting for
-   * every consumer.
-   */
-  readonly ignoreIdle?: string;
-}
-/**
- * Takes a batch of outbox rows, with the actor and tenant that CloudEvents
- * leave out. Throwing counts a failed attempt: the consumer backs off, then
- * retries one event at a time until the event that fails goes to the dead
- * letters.
- */
-type OutboxHandler = (events: readonly OutboxEvent[]) => unknown;
-interface OutboxRouteOptions extends Omit<RelayOptions, "owner">, BlockProblemOptions {
-  /** The bearer secret, such as `process.env.CRON_SECRET`. */
-  readonly secret: string | undefined;
-  /** Consumer name to the sink its events go to, or a handler that takes the rows. */
-  readonly consumers: Readonly<Record<string, EventSink | OutboxHandler>>;
-  readonly onError?: (error: DbError, consumer: string) => void;
-}
-interface OutboxRouteResult {
-  readonly consumers: Readonly<Record<string, RelayResult>>;
-  readonly budgetExhausted: boolean;
-}
-interface HistoryFilter extends CursorPageOptions<number> {
-  readonly subject?: string;
-  readonly type?: string;
-  /** Only events after this position. */
-  readonly cursor?: number;
-  readonly limit?: number;
-}
-interface Outbox {
-  /** Writes an event in the current transaction and returns its id. */
-  emit(type: string, payload?: unknown, options?: EmitOptions): AsyncResult<string>;
-  /** Creates the consumer, or changes its types. Returns its cursor position. */
-  register(consumer: string, options?: RegisterOptions): AsyncResult<number>;
-  /** Removes the consumer, so purges stop waiting for it. */
-  unregister(consumer: string): AsyncResult<boolean>;
-  /**
-   * Claims the consumer's next events, sends them to `sink` as CloudEvents and
-   * moves the cursor, until none are left or the budget runs out. A sink that
-   * throws leaves the batch for a later run with backoff, so delivery is at
-   * least once; an event that fails `maxAttempts` times goes to the dead
-   * letters.
-   */
-  relay(consumer: string, sink: EventSink, options?: RelayOptions): Promise<RelayResult>;
-  /**
-   * Like `relay`, but hands `handler` the outbox rows themselves, with
-   * `actorId`, `tenant` and `key`, for consumers inside the app (search
-   * indexing, notifications) that need the actor.
-   */
-  consume(consumer: string, handler: OutboxHandler, options?: RelayOptions): Promise<RelayResult>;
-  /** A `GET`/`POST` handler for a cron that relays every consumer at once, within one budget. */
-  relayRoute(options: OutboxRouteOptions): (request: Request) => Promise<Response>;
-  history(filter?: HistoryFilter): AsyncResult<readonly OutboxEvent[]>;
-  /** The consumer's dead letters, newest first (default 100, at most 1000). */
-  deadLetters(consumer: string, limit?: number): AsyncResult<readonly OutboxDeadLetter[]>;
-  /**
-   * Deletes up to `batch` events (default 10,000) older than `olderThan` that
-   * every consumer has passed, and dead letters older than `olderThan`. Call
-   * it again while it returns `batch`.
-   */
-  purge(olderThan?: string, batch?: number, options?: OutboxPurgeOptions): AsyncResult<number>;
-}
-/**
- * The CloudEvent for an outbox row: the row id as `id` (stable, so receivers
- * can deduplicate), the payload as `data`, the tenant as `partitionkey` and
- * the writing module as `producer`. The actor stays out of the context
- * attributes, which must not carry personal data.
- */
-declare function outboxCloudEvent(event: OutboxEvent, options: Pick<OutboxOptions, "source" | "typePrefix">): CloudEvent;
-/**
- * The outbox over a server connection (`SqlClient`), or over a
- * `BlockTransport` such as `rpcTransport(serviceClient, { schema: "api" })`
- * for apps that reach the database only through the Data API. Over a
- * transport, `emit` writes in its own transaction.
- */
-declare function createOutbox(source: SqlClient | BlockTransport, options: OutboxOptions): Outbox;
-//#endregion
-export { OutboxEvent as a, OutboxPurgeOptions as c, RegisterOptions as d, RelayOptions as f, outboxCloudEvent as h, OutboxDeadLetter as i, OutboxRouteOptions as l, createOutbox as m, HistoryFilter as n, OutboxHandler as o, RelayResult as p, Outbox as r, OutboxOptions as s, EmitOptions as t, OutboxRouteResult as u };

package/dist/plugin-CPK2HsbY.d.ts

@@ -1,190 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { w as ErrorMapper } from "./result-BchM1XZn.js";
-import { I as TableFlags, P as SchemaMeta, R as TableMeta, a as AnyModels } from "./types-CoE5Zwy4.js";
-import { _ as MutationOp, g as MutationKind, h as MutationIntent, r as Executor, v as Operation } from "./executor-Drzu3dBK.js";
-//#region src/core/plugin.d.ts
-/** Who is making the request. */
-interface Actor {
-  readonly id: string;
-  readonly kind: "user" | "service" | "anon";
-  readonly role?: string;
-  readonly email?: string;
-  /** The admin acting as this user (the `act` claim's `sub`). */
-  readonly impersonator?: string;
-}
-/**
- * Per-connection context. Server adapters fill it from the verified JWT;
- * plugins read it (`tenant()` reads `tenant`, `actor()` reads `actor`).
- */
-interface RequestContext {
-  readonly actor?: Actor;
-  readonly tenant?: string;
-  readonly claims?: Readonly<Record<string, unknown>>;
-  readonly [key: string]: unknown;
-}
-/** Plugin-specific per-call options (`withDeleted`, `hard`, ...). */
-type CallOptions = Readonly<Record<string, unknown>>;
-interface HookArgs {
-  readonly table: TableMeta;
-  readonly schema: SchemaMeta;
-  readonly context: RequestContext;
-  readonly options: CallOptions;
-  readonly now: () => Temporal.Instant;
-  /** The caller's `signal`, when it passed one. Hooks that do I/O should honor it. */
-  readonly signal?: AbortSignal;
-}
-interface MutationEvent {
-  readonly table: TableMeta;
-  /** The statement that ran. */
-  readonly kind: MutationKind;
-  /** What the caller asked for; differs from `kind` when a plugin rewrote the mutation. */
-  readonly intent?: MutationIntent;
-  /** App-cased rows returned by the mutation. A copy: changing it never changes the result. */
-  readonly rows: readonly Readonly<Record<string, unknown>>[];
-  /**
-   * App-cased primary keys of the changed rows, when they are known: from
-   * the returned rows, or from a `where` on the primary key when nothing is
-   * returned (soft deletes, `returning: false`).
-   */
-  readonly keys?: readonly Readonly<Record<string, unknown>>[];
-  /** The tenant of the write: `context.tenant`, which `tenant()` fills from the claims. */
-  readonly tenant?: string;
-  readonly context: RequestContext;
-}
-/** Runtime handle passed to `Plugin.repository`. */
-interface RepositoryApi {
-  readonly table: TableMeta;
-  readonly base: Readonly<Record<string, (...args: never[]) => unknown>>;
-}
-/**
- * Type-level repository extension, applied per table. Implement it as an
- * interface that reads `this['M']` and `this['T']`:
- *
- * ```ts
- * interface RestoreExtension extends RepositoryExtension {
- *   readonly methods: HasFlag<this['M'], this['T'], 'softDelete'> extends true
- *     ? { restore(id: string): AsyncResult<unknown> }
- *     : unknown;
- * }
- * ```
- */
-interface RepositoryExtension {
-  readonly M: AnyModels;
-  readonly T: string;
-  readonly methods: unknown;
-  readonly findArgs: unknown;
-  readonly deleteArgs: unknown;
-}
-/**
- * Applies the extensions in `E` to table `T`. `E` is a tuple of extensions (as
- * built by `use()`) or a single extension. Each is applied on its own because
- * indexing an intersection of `this`-typed interfaces overflows TS < 7.
- */
-/** Default extension of plugins that add no repository types. */
-interface NoExtension extends RepositoryExtension {
-  readonly "~none": true;
-}
-type ApplyExtension<E, M extends AnyModels, T extends keyof M, K extends "methods" | "findArgs" | "deleteArgs"> = E extends readonly [infer Head, ...infer Rest] ? ApplyOne<Head, M, T, K> & ApplyExtension<Rest, M, T, K> : ApplyOne<E, M, T, K>;
-type ApplyOne<E, M extends AnyModels, T extends keyof M, K extends "methods" | "findArgs" | "deleteArgs"> = E extends RepositoryExtension ? (E & {
-  readonly M: M;
-  readonly T: T;
-})[K] : unknown;
-/** True when table `T` has the flag set by codegen. */
-type HasFlag<M, T, F extends string> = M extends AnyModels ? T extends keyof M ? M[T]["Flags"] extends { readonly [K in F]: unknown; } ? true : false : false : false;
-/** A parameter a plugin adds to the operations of a table in the API spec. */
-interface DescribeParameter {
-  readonly name: string;
-  readonly in: "query" | "header" | "cookie";
-  readonly required?: boolean;
-  readonly description?: string;
-  /** JSON Schema 2020-12. */
-  readonly schema: Readonly<Record<string, unknown>>;
-}
-/**
- * What `Plugin.describe` can change in the API model `defineApi` builds.
- * Every method ignores tables and columns the API does not serve.
- */
-interface PluginDescribeApi {
-  readonly schema: SchemaMeta;
-  /** Prefix of generated `x-` fields, e.g. `x-better-supabase-`. */
-  readonly extensionPrefix: string;
-  /** The served tables, with the names of their operations and actions. */
-  readonly resources: readonly {
-    readonly table: TableMeta;
-    readonly operations: readonly string[];
-  }[];
-  /** Adds a parameter to the table's operations, or to the named ones. */
-  addParameter(table: string, parameter: DescribeParameter, operations?: readonly string[]): void;
-  /**
-   * Marks a column `readOnly` in the table's schemas and drops it from the
-   * required fields of request bodies. `description` is used when the
-   * column has none.
-   */
-  markReadOnly(table: string, column: string, description?: string): void;
-  /** Deep-merges JSON Schema fields into the column's schemas. */
-  describeColumn(table: string, column: string, patch: Readonly<Record<string, unknown>>): void;
-}
-declare const PLUGIN_API_VERSION = 1;
-/**
- * Plugin API v1. Every hook is optional. Hooks run in `use()` order.
- */
-interface Plugin<Name extends string = string, Ext extends RepositoryExtension = NoExtension> {
-  readonly apiVersion: 1;
-  readonly name: Name;
-  /**
-   * Hook order: `first`, then `pre`, then unmarked plugins, then `post`;
-   * plugins at the same level keep `use()` order. `first` is for plugins
-   * that check the query as the caller wrote it, before a `pre` plugin
-   * rewrites it (`rules()`). Validation is `post` so it sees columns other
-   * plugins fill.
-   */
-  readonly enforce?: "first" | "pre" | "post";
-  /**
-   * The table flags whose tables this plugin's `transformQuery` filters
-   * (`tenant()` declares `['tenant']`). Read sets warn when they read such a
-   * table, because their generated SQL function runs without the plugin.
-   * `[]` means the plugin only inspects queries. A plugin with
-   * `transformQuery` that leaves this out is assumed to filter every table.
-   */
-  readonly scopes?: readonly (keyof TableFlags)[];
-  /**
-   * `context`: derive values from the connection's context once per
-   * `connect()` and `$with()`, so `db.$context` carries them (`tenant()`
-   * adds the tenant it resolved). Runs in hook order on the context the
-   * caller passed. A throw is logged and leaves the context unchanged.
-   */
-  readonly context?: (context: RequestContext, args: {
-    readonly schema: SchemaMeta;
-  }) => RequestContext;
-  /** `ir`: rewrite an operation before it runs (filters, defaults). */
-  readonly transformQuery?: (op: Operation, args: HookArgs) => Operation;
-  /** `mutation`: rewrite a mutation or reject it by throwing a `DbException`. */
-  readonly beforeMutation?: (op: MutationOp, args: HookArgs) => MutationOp | Promise<MutationOp>;
-  /** `mutation`: observe a finished mutation. Cannot change the result. */
-  readonly afterMutation?: (event: MutationEvent) => void | Promise<void>;
-  /** `execute`: wrap the executor for tracing, caching or retries. */
-  readonly wrapExecutor?: (executor: Executor) => Executor;
-  /** `errors`: map custom SQLSTATE or hint codes to `DbError`s. */
-  readonly mapError?: ErrorMapper;
-  /** `repository`: add methods to the repositories of matching tables. */
-  readonly repository?: (api: RepositoryApi) => Readonly<Record<string, (...args: never[]) => unknown>> | undefined;
-  /**
-   * `spec`: describe what the plugin does to the served tables in the API
-   * model (`defineApi`, `createOpenApi`): parameters it reads, columns it
-   * manages. A throw is reported as `plugin-describe-failed`.
-   */
-  readonly describe?: (api: PluginDescribeApi) => void;
-  /** Phantom carrying the repository extension type. */
-  readonly "~ext"?: Ext;
-}
-type AnyPlugin = Plugin<string, any>;
-/** The plugin's repository extension; `unknown` for plugins that add none. */
-type ExtensionOf<P> = P extends Plugin<string, infer E> ? E extends NoExtension ? unknown : E : never;
-/** `E` with extension `X` appended, as a tuple. */
-type WithExtension<E, X> = unknown extends X ? E : E extends readonly unknown[] ? readonly [...E, X] : unknown extends E ? readonly [X] : readonly [E, X];
-/** Identity helper that fixes `apiVersion` and infers the plugin types. */
-declare function definePlugin<const Name extends string, Ext extends RepositoryExtension = NoExtension>(plugin: Omit<Plugin<Name, Ext>, "apiVersion"> & {
-  readonly apiVersion?: 1;
-}): Plugin<Name, Ext>;
-//#endregion
-export { ExtensionOf as a, MutationEvent as c, Plugin as d, RepositoryApi as f, definePlugin as g, WithExtension as h, CallOptions as i, NoExtension as l, RequestContext as m, AnyPlugin as n, HasFlag as o, RepositoryExtension as p, ApplyExtension as r, HookArgs as s, Actor as t, PLUGIN_API_VERSION as u };