better-supabase 0.14.0 → 0.15.1

package/dist/types-DFdg_4yN.d.ts

@@ -0,0 +1,912 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, f as Result } from "./result-DZeA5KS6.js";
+//#region src/core/executor.d.ts
+interface ExecuteContext {
+  /** Already includes the call's `timeout`, when it has one. */
+  readonly signal?: AbortSignal;
+  readonly errorMappers: readonly ErrorMapper[];
+  /**
+   * The call's `retry` setting. PostgREST passes it to postgrest-js, which
+   * retries idempotent requests on network errors, 503 and 520; executors
+   * without retries ignore it.
+   */
+  readonly retry?: boolean;
+}
+interface ExecuteResult {
+  /** Rows keyed by the aliases in the operation's selection. */
+  readonly rows: readonly Record<string, unknown>[];
+  readonly count: number | null;
+}
+/**
+ * Runs IR operations. PostgREST (`postgrestExecutor`) and SQL
+ * (`better-supabase/postgres`) are built in; any other backend can implement
+ * this interface and prove it with `testExecutor` from
+ * `better-supabase/testing`.
+ */
+interface Executor {
+  readonly name: string;
+  /** Honors `SelectOp.source`. `db.$search` fails on executors without it. */
+  readonly functionSources?: boolean;
+  execute(op: Operation, context: ExecuteContext): Promise<Result<ExecuteResult>>;
+  /** Calls a database function. Optional; `db.$rpc` fails without it. */
+  rpc?(name: string, args: Readonly<Record<string, unknown>>, context: RpcContext): Promise<Result<unknown>>;
+  /**
+   * Runs several reads together, for `db.$many`: one transaction on a SQL
+   * connection. Returns one result per operation, in order. Optional; without
+   * it `db.$many` runs the operations in parallel.
+   */
+  batch?(ops: readonly Operation[], context: ExecuteContext): Promise<readonly Result<ExecuteResult>[]>;
+}
+interface RpcContext extends ExecuteContext {
+  readonly schema: string;
+  /** The function is `stable`: send it as a GET, so read replicas can serve it. */
+  readonly get?: boolean;
+  readonly function?: FunctionMeta;
+  /**
+   * The result columns to select, by database name. Set when a column has a
+   * codec, which reads it as text: a JSON number has already lost an `int8`
+   * past 2^53 or a `numeric`'s digits.
+   */
+  readonly select?: readonly RpcColumn[];
+}
+/** One column of an `RpcContext.select` list. */
+interface RpcColumn {
+  readonly column: string;
+  readonly cast?: "text";
+}
+//#endregion
+//#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 (`membershipsExtension()` reads `tenant`,
+ * `createdByExtension()` 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 `membershipsExtension()`
+   * 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
+   * (`guards()`). 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
+   * (`membershipsExtension()` 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 (`membershipsExtension()` 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];
+/**
+ * The extensions of a plugin list, as `.use()` collects them one by one: the
+ * type `gen` gives the schema of the blocks' extensions.
+ */
+type ExtensionsOf<L extends readonly AnyPlugin[], E = unknown> = L extends readonly [infer Head, ...infer Rest extends readonly AnyPlugin[]] ? ExtensionsOf<Rest, WithExtension<E, ExtensionOf<Head>>> : E;
+/** 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
+//#region src/storage/versioning.d.ts
+/** A bucket's object versioning state in Storage. */
+type VersioningStatus = "DISABLED" | "ENABLED" | "SUSPENDED";
+/**
+ * One rule of a bucket lifecycle policy. Storage only expires noncurrent
+ * versions today.
+ */
+interface BucketLifecycleRule {
+  /** Storage generates one when you omit it. */
+  readonly id?: string;
+  /** Defaults to `Enabled`. `Disabled` keeps the rule stored but inactive. */
+  readonly status?: "Enabled" | "Disabled";
+  readonly noncurrentVersionExpiration: {
+    /**
+     * How old a noncurrent version must be before it expires, in days (at least
+     * 1).
+     */
+    readonly noncurrentDays: number;
+    /**
+     * Keep this many of the newest noncurrent versions regardless of age (1 to
+     * 100).
+     */
+    readonly newerNoncurrentVersions?: number;
+  };
+}
+/** A bucket lifecycle policy: 1 to 1000 rules, applied by `bucket.apply()`. */
+interface BucketLifecycle {
+  readonly rules: readonly [BucketLifecycleRule, ...BucketLifecycleRule[]];
+}
+/** One version of an object, newest first in `versions()`. */
+interface ObjectVersion {
+  readonly versionId: string;
+  /** The version the path serves now. */
+  readonly current: boolean;
+  /** A delete marker hides the object without removing its versions. */
+  readonly deleteMarker: boolean;
+  readonly size?: number;
+  readonly contentType?: string;
+  readonly createdAt: string | null;
+  /** When the version stopped being current. */
+  readonly archivedAt: string | null;
+}
+//#endregion
+//#region src/schema/types.d.ts
+type Casing = "snake" | "camel";
+/** Runtime metadata for one column. Keyed by the app (cased) column name. */
+interface ColumnMeta {
+  /** Database column name. */
+  readonly db: string;
+  /** Postgres type name (`uuid`, `text`, `timestamptz`, `note_kind`). */
+  readonly type: string;
+  readonly nullable: boolean;
+  /**
+   * An insert may leave the column out: it has a default, a `before insert`
+   * trigger can fill it, or `tables.<t>.insertOptional` lists it.
+   */
+  readonly hasDefault: boolean;
+  readonly generated?: boolean;
+  /** Identity column; `'always'` columns can't be written. */
+  readonly identity?: "always" | "by default";
+  /**
+   * `false` when inserts can't set this column (generated, identity always,
+   * view).
+   */
+  readonly insertable?: false;
+  /** `false` when updates can't set this column. */
+  readonly updatable?: false;
+  /**
+   * `false` when signed-in users can't read the column (an app table column
+   * with `access: "server"`). Reads without `select` leave it out; the service
+   * role can still select it by name.
+   */
+  readonly selectable?: false;
+  readonly array?: boolean;
+  readonly json?: boolean;
+  /** Allowed values for enum columns and CHECK-constraint unions. */
+  readonly enum?: readonly string[];
+  /** How values are decoded from the wire (see the `codecs` config). */
+  readonly codec?: Codec;
+  /**
+   * Listed in `config.sensitive`; the `noSensitiveSelect` rule guards reads of
+   * it.
+   */
+  readonly sensitive?: true;
+  /**
+   * Bucket id of the objects this text column points to
+   * (`config.storagePaths`).
+   */
+  readonly storage?: string;
+  /** The column's `COMMENT ON`, without its `@example` and `@deprecated` lines. */
+  readonly description?: string;
+  /** The column's comment has a `@deprecated` line. */
+  readonly deprecated?: true;
+}
+/**
+ * Runtime representation for a column: `instant` decodes `timestamptz` to
+ * `Temporal.Instant`, `plainDateTime` decodes `timestamp` to
+ * `Temporal.PlainDateTime`, and `bigint` and `string` read the exact text of
+ * `int8`/`numeric` values.
+ */
+type Codec = "instant" | "plainDateTime" | "bigint" | "string" | "utcString";
+interface RelationMeta {
+  /** App key of the target table. */
+  readonly table: string;
+  readonly kind: "one" | "many";
+  readonly nullable: boolean;
+  /** Foreign key constraint name, used as the PostgREST embed hint. */
+  readonly foreignKey: string;
+  /** App column names on the source table. */
+  readonly columns: readonly string[];
+  /** App column names on the target table. */
+  readonly references: readonly string[];
+  /** `forward`: this table holds the FK. `reverse`: the target holds it. */
+  readonly direction: "forward" | "reverse";
+  /**
+   * What deleting the referenced row does to the referencing rows, when it
+   * changes them.
+   */
+  readonly onDelete?: "cascade" | "set null" | "set default";
+}
+interface TableFlags {
+  /** App column holding the soft-delete timestamp. */
+  readonly softDelete?: string;
+  readonly timestamps?: {
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+  };
+  /** App column holding the tenant id. */
+  readonly tenant?: string;
+  readonly actor?: {
+    readonly createdBy?: string;
+    readonly updatedBy?: string;
+    /** The admin behind an impersonated write; `null` otherwise. */
+    readonly impersonatedBy?: string;
+  };
+  /** App column used for optimistic concurrency, usually `updatedAt`. */
+  readonly version?: string;
+}
+interface TableMeta {
+  /** App key of the table (`customerTags` in camel casing). */
+  readonly key: string;
+  /** Database table name. */
+  readonly name: string;
+  readonly schema: string;
+  readonly kind: "table" | "view";
+  readonly columns: Readonly<Record<string, ColumnMeta>>;
+  /** App column names. */
+  readonly primaryKey: readonly string[];
+  /** Constraint name to app column names. */
+  readonly uniqueKeys: Readonly<Record<string, readonly string[]>>;
+  readonly relations: Readonly<Record<string, RelationMeta>>;
+  readonly flags: TableFlags;
+  /** The table's `COMMENT ON`, without its `@example` and `@deprecated` lines. */
+  readonly description?: string;
+  /** The table's comment has a `@deprecated` line. */
+  readonly deprecated?: true;
+}
+interface FunctionMeta extends FunctionSignature {
+  readonly name: string;
+  readonly schema: string;
+  /**
+   * Every signature of an overloaded function, in signature order. The fields
+   * above describe the first one; `$rpc` picks the signature whose argument
+   * names match the call.
+   */
+  readonly overloads?: readonly FunctionSignature[];
+}
+interface FunctionSignature {
+  readonly args: readonly {
+    readonly name: string;
+    readonly type: string;
+    /** The argument has a default; set in `overloads` only. */
+    readonly optional?: boolean;
+  }[];
+  readonly returns: string;
+  readonly returnsSet: boolean;
+  readonly volatility: "immutable" | "stable" | "volatile";
+  /**
+   * How `$rpc` decodes the returned rows, present when decoding changes them:
+   * the rows of a table (by app key), or a `returns table (...)` record.
+   */
+  readonly result?: FunctionResult;
+}
+type FunctionResult = {
+  readonly table: string;
+} | {
+  readonly columns: readonly ResultColumn[];
+};
+/** A column of a `returns table (...)` result. */
+interface ResultColumn {
+  /** Database name, the key PostgREST returns. */
+  readonly db: string;
+  /** App name, when the casing changes it. */
+  readonly name?: string;
+  readonly codec?: Codec;
+}
+interface SchemaMeta {
+  readonly version: 1;
+  readonly casing: Casing;
+  readonly tables: Readonly<Record<string, TableMeta>>;
+  readonly enums: Readonly<Record<string, readonly string[]>>;
+  readonly functions: Readonly<Record<string, FunctionMeta>>;
+  readonly buckets?: Readonly<Record<string, BucketMeta>>;
+  readonly topics?: Readonly<Record<string, string>>;
+  /**
+   * Tables that broadcast change signals (`config.realtime.tables`), keyed by
+   * app key.
+   */
+  readonly realtime?: Readonly<Record<string, RealtimeTableMeta>>;
+  /** Claim names from `config.claims` that differ from the defaults. */
+  readonly claims?: Partial<ClaimsMeta>;
+}
+/** The claim names the SQL modules, codegen and runtime defaults agree on. */
+interface ClaimsMeta {
+  /** Top-level claim holding the active tenant id. Defaults to `tenant_id`. */
+  readonly tenant: string;
+  /**
+   * `scope` of the tenant entries in the `memberships` claim. Defaults to
+   * `tenant`.
+   */
+  readonly scope: string;
+  /**
+   * Claim holding plan features per tenant (`{ [tenantId]: string[] }`).
+   * Defaults to `features`.
+   */
+  readonly features: string;
+  /**
+   * Claim holding the caller's memberships (`{ scope, id, role }[]`). Defaults
+   * to `memberships`.
+   */
+  readonly memberships: string;
+}
+interface RealtimeTableMeta {
+  /** App column whose value scopes the broadcast topic. */
+  readonly tenant?: string;
+  /** App column of the row's user (`realtime.users`): the topic is per user. */
+  readonly user?: string;
+}
+type BucketPolicyName = "tenant" | "owner" | "public" | "none";
+/**
+ * SQL templates a Storage or Realtime policy calls instead of the access
+ * contract, usually an authorization provider's (`authorization.functions`).
+ * `{permission}` is the key as a literal and `{scope}` the policy's scope.
+ */
+interface AccessPolicySql {
+  /**
+   * The ids of the `{scope}` instances where the caller holds `{permission}`,
+   * as a set.
+   */
+  readonly idsWith: string;
+  /** Whether the caller holds `{permission}` platform-wide. */
+  readonly isPlatform: string;
+}
+/**
+ * A policy through the SQL modules' [access
+ * contract](/docs/blocks/permissions): `tenant_ids_with(permission)` for the
+ * tenant id in the path, or `is_platform(permission)`. Works with every access
+ * model. With `sql`, it calls those templates instead, for any scope they
+ * take.
+ */
+interface AccessBucketPolicy {
+  readonly access: {
+    /** Downloads, signed URLs, renders and metadata reads. */
+    readonly read: string;
+    /** Listing; without it `read` covers listing too. */
+    readonly list?: string;
+    /** Uploads, updates and moves; also deletes unless `delete` is set. */
+    readonly write: string;
+    readonly delete?: string;
+  };
+  /**
+   * `tenant` (default) checks the path's tenant segment; `platform` checks
+   * platform permissions. With `sql`, any scope name its templates take.
+   */
+  readonly scope?: string;
+  /**
+   * 1-based path segment holding the scope id. Defaults to the
+   * `{organizationId}` segment.
+   */
+  readonly segment?: number;
+  /**
+   * The templates to call, or `"provider"` for `authorization.functions` from
+   * the config, which `gen` copies in.
+   */
+  readonly sql?: AccessPolicySql | "provider";
+}
+/**
+ * An access topic policy: `select` (receive) and `insert` (send) on
+ * `realtime.messages`.
+ */
+interface AccessTopicPolicy {
+  readonly receive: string;
+  /** Lets clients send on the topic with this permission. */
+  readonly send?: string;
+  /** As for {@link AccessBucketPolicy}. */
+  readonly scope?: string;
+  /**
+   * 1-based `:`-separated topic segment holding the scope id. Defaults to the
+   * `{organizationId}` segment.
+   */
+  readonly segment?: number;
+  /** As for {@link AccessBucketPolicy}. */
+  readonly sql?: AccessPolicySql | "provider";
+}
+interface BucketMeta {
+  readonly id: string;
+  readonly public: boolean;
+  readonly path: string | readonly [string, ...string[]];
+  readonly policy?: BucketPolicyName | AccessBucketPolicy;
+  /**
+   * Claim paths for the tenant policy, when `config.claims.tenant` is not the
+   * default.
+   */
+  readonly tenant?: {
+    readonly claim: readonly string[];
+  };
+  readonly fileSizeLimit?: string;
+  readonly allowedMimeTypes?: readonly string[];
+  readonly versioning?: boolean;
+  readonly lifecycle?: BucketLifecycle;
+}
+interface RelationTypes {
+  readonly table: string;
+  readonly kind: "one" | "many";
+  readonly nullable: boolean;
+}
+interface ModelFlags {
+  readonly softDelete?: string;
+  readonly timestamps?: true;
+  readonly tenant?: string;
+  readonly actor?: true;
+  readonly version?: string;
+}
+interface ModelTypes {
+  readonly Row: object;
+  readonly Insert: object;
+  readonly Update: object;
+  readonly Relations: object;
+  readonly PrimaryKey: PropertyKey;
+  readonly UniqueKeys: object;
+  /** CHECK constraint names. */
+  readonly Checks?: string;
+  /** Foreign key constraint names on this table. */
+  readonly ForeignKeys?: string;
+  readonly Flags: ModelFlags;
+}
+type AnyModels = {
+  readonly [table: string]: ModelTypes;
+};
+type FunctionTypes = {
+  readonly Args: object;
+  readonly Returns: unknown;
+};
+type AnyFunctions = {
+  readonly [name: string]: FunctionTypes;
+};
+/**
+ * Carries the model types next to the runtime metadata. Created by
+ * `defineSchema` in the generated module.
+ */
+interface Schema<M extends AnyModels = AnyModels, D = unknown, F extends AnyFunctions = AnyFunctions, S extends string = string, E = unknown> {
+  readonly meta: SchemaMeta;
+  /**
+   * The repository extensions of the installed blocks (`trashExtension()`,
+   * ...). `defineSupabase(schema)` installs them first.
+   */
+  readonly extensions?: readonly AnyPlugin[];
+  /** Phantom. Never present at runtime. */
+  readonly "~types"?: {
+    readonly models: M;
+    readonly database: D;
+    readonly functions: F;
+    /** The `config.records` type names. */
+    readonly subjects: S;
+    /** The repository extensions' types, as `.use()` collects them. */
+    readonly extensions: E;
+  };
+}
+/**
+ * Columns of `T` that `Insert` can set: generated columns (`?: never` in
+ * `Insert`) are left out.
+ */
+type WritableColumns<M extends AnyModels, T extends keyof M> = [M[T]["Insert"]] extends [never] ? never : { [K in keyof M[T]["Insert"]]-?: [Exclude<M[T]["Insert"][K], undefined>] extends [never] ? never : K; }[keyof M[T]["Insert"]];
+/**
+ * Columns of `T` the database fills (generated or identity `always`): in `Row`,
+ * never in `Insert`.
+ */
+type GeneratedColumns<M extends AnyModels, T extends keyof M> = [M[T]["Insert"]] extends [never] ? never : Exclude<keyof M[T]["Insert"], WritableColumns<M, T>>;
+type ModelsOf<S> = S extends Schema<infer M> ? M : never;
+type DatabaseOf<S> = S extends Schema<AnyModels, infer D> ? D : never;
+type FunctionsOf<S> = S extends Schema<AnyModels, unknown, infer F> ? F : never;
+/** The schema's subject types (`config.records`), `string` without a registry. */
+type SubjectTypeOf<S> = S extends Schema<AnyModels, unknown, AnyFunctions, infer T> ? T : string;
+/** One subject: its type and its id as text. */
+interface RecordRef<T extends string = string> {
+  readonly type: T;
+  readonly id: string;
+}
+type TableKey<M extends AnyModels> = Extract<keyof M, string>;
+type Row<M extends AnyModels, T extends keyof M> = M[T]["Row"];
+type Insert<M extends AnyModels, T extends keyof M> = M[T]["Insert"];
+type Update<M extends AnyModels, T extends keyof M> = M[T]["Update"];
+type Relations<M extends AnyModels, T extends keyof M> = M[T]["Relations"];
+type Flags<M extends AnyModels, T extends keyof M> = M[T]["Flags"];
+type PrimaryKeyColumn<M extends AnyModels, T extends keyof M> = Extract<M[T]["PrimaryKey"], keyof Row<M, T>>;
+type UniqueKeyName<M extends AnyModels, T extends keyof M> = Extract<keyof M[T]["UniqueKeys"], string>;
+type UniqueKeyColumns<M extends AnyModels, T extends keyof M, K extends keyof M[T]["UniqueKeys"]> = Extract<M[T]["UniqueKeys"][K] extends readonly (infer C)[] ? C : never, keyof Row<M, T>>;
+/**
+ * Values for exactly one unique key: the primary key columns, or the columns of
+ * one named unique constraint or unique index.
+ */
+type UniqueWhere<M extends AnyModels, T extends keyof M> = { readonly [C in PrimaryKeyColumn<M, T>]: Row<M, T>[C]; } | { [K in keyof M[T]["UniqueKeys"]]: { readonly [C in UniqueKeyColumns<M, T, K>]: Row<M, T>[C]; }; }[keyof M[T]["UniqueKeys"]];
+/** Every unique constraint name in the schema, for `isConflict`. */
+type UniqueConstraint<M extends AnyModels> = { [T in keyof M]: Extract<keyof M[T]["UniqueKeys"], string>; }[keyof M];
+/** Every CHECK constraint name in the schema, for `isCheck`. */
+type CheckConstraint<M extends AnyModels> = { [T in keyof M]: M[T] extends {
+  readonly Checks: infer C extends string;
+} ? C : never; }[keyof M];
+/** Every foreign key constraint name in the schema, for `isForeignKey`. */
+type ForeignKeyConstraint<M extends AnyModels> = { [T in keyof M]: M[T] extends {
+  readonly ForeignKeys: infer C extends string;
+} ? C : never; }[keyof M];
+type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : never;
+/** A single value for single-column keys, an object for composite keys. */
+type PrimaryKeyValue<M extends AnyModels, T extends keyof M> = true extends IsUnion<PrimaryKeyColumn<M, T>> ? { readonly [K in PrimaryKeyColumn<M, T>]: Row<M, T>[K]; } : Row<M, T>[PrimaryKeyColumn<M, T>];
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+//#endregion
+//#region src/ir/types.d.ts
+/**
+ * The query IR. Every repository call becomes one of these operations; the
+ * executor compiles it to PostgREST or SQL. Column names in the IR are database
+ * names; `Selection` carries the app aliases.
+ */
+type ColumnOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "is" | "like" | "ilike" | "match" | "imatch" | "contains" | "containedBy" | "overlaps" | "fts";
+type Quantifier = "some" | "none" | "every";
+type Condition = {
+  readonly kind: "and";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "or";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "not";
+  readonly item: Condition;
+} | {
+  readonly kind: "column";
+  readonly column: string;
+  readonly op: ColumnOp;
+  readonly value: unknown;
+  /** Full-text search configuration for `fts`. */
+  readonly config?: string;
+  /**
+   * The column is `json`/`jsonb`: containment values are JSON documents,
+   * also when they are arrays, never Postgres array literals.
+   */
+  readonly json?: true;
+  /**
+   * Keys into a json column: the condition compares the text at this path
+   * (`column->a->>b`, `column #>> '{a,b}'`), and `is null` holds when the
+   * key is missing or JSON `null`.
+   */
+  readonly path?: readonly string[];
+} | {
+  readonly kind: "relation";
+  readonly name: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly quantifier: Quantifier;
+  readonly where: Condition | undefined;
+};
+interface SelectColumn {
+  /** Key in the returned row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the column as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  /** Decodes the returned value (see `ColumnMeta.codec`). */
+  readonly codec?: Codec;
+}
+interface OrderTerm {
+  readonly column: string;
+  readonly direction: "asc" | "desc";
+  readonly nulls?: "first" | "last";
+  /**
+   * Added by the repository (the primary key order of `list`), not asked for by
+   * the caller, so a split read may sort it approximately.
+   */
+  readonly implicit?: true;
+  /**
+   * Sort `aggregate()` groups by this aggregate of `column`; `count` counts the
+   * group's rows and its `column` is `*`.
+   */
+  readonly aggregate?: AggregateFn | "count";
+  /** Sort by `column` of this to-one relation's row (only on the root table). */
+  readonly relation?: {
+    readonly name: string;
+    readonly relation: RelationMeta;
+    readonly target: TableMeta;
+  };
+}
+interface Include {
+  readonly alias: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  /** Drop parent rows without a match (`!inner`). */
+  readonly required: boolean;
+  /**
+   * `_count` include: returns the number of matching related rows instead of
+   * rows, folded into `row._count[count]` when decoded.
+   */
+  readonly count?: string;
+  /**
+   * `_sum`/`_avg`/`_min`/`_max` include: `selection.aggregate` holds the
+   * measures, folded into `row[`_${fn}`][name]` when decoded.
+   */
+  readonly aggregate?: {
+    readonly fn: AggregateFn;
+    readonly name: string;
+  };
+}
+type AggregateFn = "sum" | "avg" | "min" | "max";
+interface Measure {
+  readonly fn: AggregateFn;
+  /** Key in the returned row (`_sum_amount`, or the column alias in an include). */
+  readonly key: string;
+  /** App column name, the key under `_sum` in the decoded row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the result as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  readonly codec?: Codec;
+}
+/**
+ * Aggregates instead of rows. `Selection.columns` become the grouping columns;
+ * without any, the result is exactly one row.
+ */
+interface Aggregation {
+  /** Also return `_count`, the number of rows in each group. */
+  readonly count: boolean;
+  readonly measures: readonly Measure[];
+}
+interface Selection {
+  readonly columns: readonly SelectColumn[];
+  readonly includes: readonly Include[];
+  readonly aggregate?: Aggregation;
+}
+type CountMode = "exact" | "planned" | "estimated";
+interface SelectOp {
+  readonly kind: "select";
+  readonly table: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  readonly offset: number | undefined;
+  readonly count: CountMode | undefined;
+  /** Only count, return no rows. */
+  readonly head: boolean;
+  readonly single: "one" | "maybe" | undefined;
+  /**
+   * `limit` includes one row past the page, which `page()` reads to set
+   * `hasMore`.
+   */
+  readonly lookAhead?: boolean;
+  /**
+   * `limit` bounds a check, not a page: `get` reads two rows to detect a second
+   * match.
+   */
+  readonly unpaged?: boolean;
+  /**
+   * Read from this set-returning function instead of the table (`db.$search`).
+   * Only executors with `functionSources` honor it.
+   */
+  readonly source?: FunctionSource;
+}
+/** A function returning `setof <table>`, called with named arguments. */
+interface FunctionSource {
+  readonly schema: string;
+  readonly name: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+/** The statement a mutation runs. */
+type MutationKind = "insert" | "upsert" | "update" | "delete";
+/**
+ * What the caller asked for: `softDelete` is a `delete` that a plugin turned
+ * into an update.
+ */
+type MutationIntent = MutationKind | "softDelete";
+interface MutationBase {
+  /**
+   * What the caller asked for, when a plugin rewrote the mutation into another
+   * kind. The plugin that rewrites it sets this; mutation events report it.
+   */
+  readonly intent?: MutationIntent;
+  /**
+   * How a mutation without `returning` counts the rows it wrote. Defaults to
+   * `exact`; SQL executors always return the statement's own row count.
+   */
+  readonly count?: CountMode;
+}
+interface BoundedMutation extends MutationBase {
+  /**
+   * The most rows the statement may change. More fails with `max_affected` and
+   * writes nothing. Over PostgREST it needs PostgREST 13 or later.
+   */
+  readonly maxAffected?: number;
+}
+interface InsertOp extends MutationBase {
+  readonly kind: "insert";
+  readonly table: TableMeta;
+  /** Rows keyed by database column names. */
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  readonly returning: Selection | undefined;
+  readonly onConflict: {
+    readonly columns: readonly string[];
+    readonly action: "update" | "ignore";
+  } | undefined;
+  /**
+   * In a multi-row insert, columns some rows leave out become `null` instead of
+   * their column default.
+   */
+  readonly defaultToNull: boolean;
+}
+interface UpdateOp extends BoundedMutation {
+  readonly kind: "update";
+  readonly table: TableMeta;
+  /** Keyed by database column names. */
+  readonly set: Readonly<Record<string, unknown>>;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+interface DeleteOp extends BoundedMutation {
+  readonly kind: "delete";
+  readonly table: TableMeta;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+type Operation = SelectOp | InsertOp | UpdateOp | DeleteOp;
+type MutationOp = InsertOp | UpdateOp | DeleteOp;
+declare const and: (...items: (Condition | undefined)[]) => Condition | undefined;
+declare const or: (...items: Condition[]) => Condition;
+declare const not: (item: Condition) => Condition;
+declare const column: (name: string, op: ColumnOp, value: unknown) => Condition;
+//#endregion
+export { RecordRef as $, BucketMeta as A, NoExtension as At, FunctionMeta as B, Executor as Bt, not as C, ApplyExtension as Ct, AccessTopicPolicy as D, HasFlag as Dt, AccessPolicySql as E, ExtensionsOf as Et, Codec as F, RequestContext as Ft, GeneratedColumns as G, FunctionSignature as H, ColumnMeta as I, WithExtension as It, ModelTypes as J, Insert as K, DatabaseOf as L, definePlugin as Lt, Casing as M, Plugin as Mt, CheckConstraint as N, RepositoryApi as Nt, AnyFunctions as O, HookArgs as Ot, ClaimsMeta as P, RepositoryExtension as Pt, RealtimeTableMeta as Q, Flags as R, ExecuteContext as Rt, column as S, AnyPlugin as St, AccessBucketPolicy as T, ExtensionOf as Tt, FunctionTypes as U, FunctionResult as V, RpcContext as Vt, FunctionsOf as W, PrimaryKeyColumn as X, ModelsOf as Y, PrimaryKeyValue as Z, SelectColumn as _, BucketLifecycle as _t, CountMode as a, Schema as at, UpdateOp as b, VersioningStatus as bt, Include as c, SubjectTypeOf as ct, MutationIntent as d, TableMeta as dt, RelationMeta as et, MutationKind as f, UniqueConstraint as ft, Quantifier as g, WritableColumns as gt, OrderTerm as h, Update as ht, Condition as i, Row as it, BucketPolicyName as j, PLUGIN_API_VERSION as jt, AnyModels as k, MutationEvent as kt, InsertOp as l, TableFlags as lt, Operation as m, UniqueWhere as mt, Aggregation as n, Relations as nt, DeleteOp as o, SchemaMeta as ot, MutationOp as p, UniqueKeyName as pt, ModelFlags as q, ColumnOp as r, ResultColumn as rt, FunctionSource as s, Simplify as st, AggregateFn as t, RelationTypes as tt, Measure as u, TableKey as ut, SelectOp as v, BucketLifecycleRule as vt, or as w, CallOptions as wt, and as x, Actor as xt, Selection as y, ObjectVersion as yt, ForeignKeyConstraint as z, ExecuteResult as zt };