better-supabase 0.11.0 → 0.13.0

package/dist/types-DYXhFhmQ.d.ts

@@ -0,0 +1,251 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-mijqfoJN.js";
+import { t as StandardSchemaV1 } from "./standard-16AIDny5.js";
+import { r as FieldsOf } from "./block-fields-DnXkMney.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as BlockTransport } from "./block-transport-DBPhgF3W.js";
+import { r as BlockTemporalOptions } from "./block-helpers-DyA5BAW4.js";
+import { n as BlockHooks } from "./block-hooks-BadAniNI.js";
+import { i as AiMessage } from "./message-Bg4TKA12.js";
+//#region src/blocks/upload-claim.d.ts
+/** The claim step of a Storage API, such as the one `supportStorage` returns. */
+interface UploadClaimStorage {
+  claimSignedUpload?(bucket: string, path: string): PromiseLike<{
+    readonly data: unknown;
+    readonly error: unknown;
+  }>;
+}
+//#endregion
+//#region src/blocks/ai-files/types.d.ts
+interface StorageReply<T> {
+  readonly data: T | null;
+  readonly error: unknown;
+}
+/** The `supabase.storage.from(bucket)` methods the block uses. */
+interface AiFileBucket {
+  createSignedUploadUrl(path: string): PromiseLike<StorageReply<{
+    readonly signedUrl: string;
+    readonly token: string;
+  }>>;
+  createSignedUrl(path: string, expiresIn: number): PromiseLike<StorageReply<{
+    readonly signedUrl: string;
+  }>>;
+  download(path: string): PromiseLike<StorageReply<Blob>>;
+  remove(paths: string[]): PromiseLike<StorageReply<unknown>>;
+  upload?(path: string, body: Blob | ArrayBuffer | Uint8Array, options?: {
+    readonly contentType?: string;
+    readonly upsert?: boolean;
+  }): PromiseLike<StorageReply<unknown>>;
+}
+/** `supabase.storage`, typed structurally. */
+interface AiFileStorage extends UploadClaimStorage {
+  from(bucket: string): AiFileBucket;
+}
+interface AiFilesOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the file columns the app adds
+   * (`blocks.ai-files.options.extraColumns`), keyed by column name. It types
+   * and parses them on the file reads, and validates them on `files.upload` and
+   * `files.store`, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiFiles<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /** Calls as the user: `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** The user's `supabase.storage`, so the bucket policies apply. */
+  readonly storage: AiFileStorage;
+  /** Calls as the service role, for `store`, provider files and `purge`. */
+  readonly service?: BlockTransport;
+  /** The service role's `supabase.storage`, for `store` and `purge`. */
+  readonly serviceStorage?: AiFileStorage;
+  /** The module schema (`blocks["ai-files"].schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** Lifetime of a signed download URL in seconds. Default 300. */
+  readonly downloadTtl?: number;
+  /** The most bytes `read` returns before it fails. Default 50 MB. */
+  readonly maxBytes?: number;
+}
+type AiFileStatus = "pending" | "ready" | "failed";
+type AiFileSource = "upload" | "generated" | "provider";
+interface AiFile {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly ownerId: string;
+  readonly chatId: string | undefined;
+  readonly projectId: string | undefined;
+  readonly bucket: string;
+  /** `{organizationId}/{ownerId}/{id}/{filename}` in the bucket. */
+  readonly path: string;
+  readonly mediaType: string;
+  readonly filename: string;
+  readonly size: number;
+  readonly sha256: string | undefined;
+  readonly status: AiFileStatus;
+  readonly source: AiFileSource;
+  readonly createdAt: Temporal.Instant;
+  readonly uploadedAt: Temporal.Instant | undefined;
+  readonly expiresAt: Temporal.Instant | undefined;
+}
+interface NewAiFile {
+  readonly filename: string;
+  readonly mediaType: string;
+  /** Bytes; `confirm()` replaces it with the stored size. */
+  readonly size: number;
+  readonly chatId?: string;
+  readonly projectId?: string;
+}
+interface AiFileUpload<F extends object = Record<never, never>> {
+  readonly file: AiFile & F;
+  /**
+   * PUT the file here, or pass `token` to `uploadToSignedUrl(path, token,
+   * file)`.
+   */
+  readonly signedUrl: string;
+  readonly token: string;
+}
+interface StoredAiFile {
+  /** The user the file belongs to. */
+  readonly ownerId: string;
+  readonly filename: string;
+  readonly mediaType: string;
+  readonly data: Uint8Array | Blob;
+  readonly chatId?: string;
+  readonly source?: AiFileSource;
+}
+interface AiProviderFile {
+  readonly fileId: string;
+  readonly provider: string;
+  /** What the provider's file API returned: a file id or a file URI. */
+  readonly reference: string;
+  readonly expiresAt: Temporal.Instant | undefined;
+}
+type AiDocumentKind = "text" | "code" | "sheet" | "image";
+interface AiDocument {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly ownerId: string;
+  readonly chatId: string | undefined;
+  readonly kind: AiDocumentKind;
+  readonly title: string;
+  readonly version: number;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A document with the content of its current version. */
+interface AiDocumentWithContent extends AiDocument {
+  readonly content: string | undefined;
+  /** A path in the bucket, for an image or a large document. */
+  readonly storagePath: string | undefined;
+}
+interface AiDocumentVersion {
+  readonly documentId: string;
+  readonly version: number;
+  readonly content: string | undefined;
+  readonly storagePath: string | undefined;
+  /** The assistant message that wrote this version. */
+  readonly messageId: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface NewAiDocument {
+  readonly kind: AiDocumentKind;
+  readonly title: string;
+  readonly content?: string;
+  readonly storagePath?: string;
+  readonly chatId?: string;
+  readonly messageId?: string;
+  /** The service role only: the user the document belongs to. */
+  readonly ownerId?: string;
+}
+interface AiDocumentEdit {
+  readonly content?: string;
+  readonly storagePath?: string;
+  readonly title?: string;
+  readonly messageId?: string;
+  /** Fails with `conflict` when the document moved past this version. */
+  readonly expectedVersion?: number;
+}
+interface AiSuggestion {
+  readonly id: string;
+  readonly documentId: string;
+  readonly version: number;
+  readonly originalText: string;
+  readonly suggestedText: string;
+  readonly description: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly resolvedAt: Temporal.Instant | undefined;
+  readonly accepted: boolean | undefined;
+}
+/** `F` is the extra file fields `options.fields` describes. */
+interface AiFiles<F extends object = Record<never, never>> {
+  readonly files: {
+    /**
+     * Reserves the file and returns a signed upload URL for its path. Keys
+     * besides the input's own are the file's extra columns.
+     */
+    upload(organizationId: string, file: NewAiFile & Partial<F>): AsyncResult<AiFileUpload<F>>;
+    /** Marks the upload done once the object exists. */
+    confirm(fileId: string, sha256?: string): AsyncResult<AiFile & F>;
+    get(fileId: string): AsyncResult<AiFile & F>;
+    /** The file a `supabase-storage://` URL names, when the caller may read it. */
+    resolve(url: string | URL): AsyncResult<AiFile & F>;
+    list(chatId: string): AsyncResult<readonly (AiFile & F)[]>;
+    /** A signed download URL that expires after `downloadTtl`. */
+    sign(file: AiFile | string): AsyncResult<string>;
+    /** The bytes of a ready file, refusing more than `maxBytes`. */
+    read(file: AiFile | string): AsyncResult<{
+      readonly file: AiFile & F;
+      readonly data: Uint8Array;
+    }>;
+    /** Deletes the object and the record. */
+    remove(fileId: string): AsyncResult<boolean>;
+    /** Writes a ready file for `ownerId` from the server (service role). */
+    store(organizationId: string, file: StoredAiFile & Partial<F>): AsyncResult<AiFile & F>;
+    /**
+     * Deletes stale pending uploads, expired files and the files of deleted
+     * chats, then their objects (service role). Returns how many.
+     */
+    purge(options?: {
+      readonly olderThan?: string;
+      readonly batch?: number;
+    }): AsyncResult<number>;
+  };
+  readonly providerFiles: {
+    /** The provider's reference while it is valid (service role). */
+    get(fileId: string, provider: string): AsyncResult<AiProviderFile | undefined>;
+    set(fileId: string, provider: string, reference: string, expiresAt?: Temporal.Instant): AsyncResult<boolean>;
+    /** References that expire within `horizon` (an interval, default `1 day`). */
+    expiring(horizon?: string, batch?: number): AsyncResult<readonly AiProviderFile[]>;
+  };
+  readonly documents: {
+    create(organizationId: string, document: NewAiDocument): AsyncResult<AiDocument>;
+    get(documentId: string): AsyncResult<AiDocumentWithContent>;
+    update(documentId: string, edit: AiDocumentEdit): AsyncResult<AiDocument>;
+    /** Writes `version` as the newest version again. */
+    rollback(documentId: string, version: number): AsyncResult<AiDocument>;
+    versions(documentId: string): AsyncResult<readonly AiDocumentVersion[]>;
+    remove(documentId: string): AsyncResult<boolean>;
+    suggest(documentId: string, suggestion: {
+      readonly originalText: string;
+      readonly suggestedText: string;
+      readonly description?: string;
+    }): AsyncResult<AiSuggestion>;
+    suggestions(documentId: string, options?: {
+      readonly openOnly?: boolean;
+    }): AsyncResult<readonly AiSuggestion[]>;
+    resolve(suggestionId: string, accepted: boolean): AsyncResult<AiSuggestion>;
+  };
+  /**
+   * Replaces the `supabase-storage://` URLs of file parts with signed download
+   * URLs, so a browser or a provider can fetch them. Parts the caller may not
+   * read keep their URL.
+   */
+  sign(messages: readonly AiMessage[]): Promise<readonly AiMessage[]>;
+}
+//#endregion
+export { NewAiFile as _, AiDocumentWithContent as a, AiFileSource as c, AiFileUpload as d, AiFiles as f, NewAiDocument as g, AiSuggestion as h, AiDocumentVersion as i, AiFileStatus as l, AiProviderFile as m, AiDocumentEdit as n, AiFile as o, AiFilesOptions as p, AiDocumentKind as r, AiFileBucket as s, AiDocument as t, AiFileStorage as u, StoredAiFile as v, UploadClaimStorage as y };

package/dist/types-DmshMaXz.d.ts

@@ -0,0 +1,421 @@
+/// <reference lib="esnext.temporal" />
+//#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/access):
+ * `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> {
+  readonly meta: SchemaMeta;
+  /** Phantom. Never present at runtime. */
+  readonly "~types"?: {
+    readonly models: M;
+    readonly database: D;
+    readonly functions: F;
+    /** The `config.subjects` type names. */
+    readonly subjects: S;
+  };
+}
+/**
+ * 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.subjects`), `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 SubjectRef<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
+export { RelationTypes as A, TableKey as B, ModelFlags as C, PrimaryKeyValue as D, PrimaryKeyColumn as E, SchemaMeta as F, Update as G, UniqueConstraint as H, Simplify as I, BucketLifecycleRule as J, WritableColumns as K, SubjectRef as L, ResultColumn as M, Row as N, RealtimeTableMeta as O, Schema as P, SubjectTypeOf as R, Insert as S, ModelsOf as T, UniqueKeyName as U, TableMeta as V, UniqueWhere as W, VersioningStatus as X, ObjectVersion as Y, FunctionResult as _, AnyModels as a, FunctionsOf as b, Casing as c, Codec as d, ColumnMeta as f, FunctionMeta as g, ForeignKeyConstraint as h, AnyFunctions as i, Relations as j, RelationMeta as k, CheckConstraint as l, Flags as m, AccessPolicySql as n, BucketMeta as o, DatabaseOf as p, BucketLifecycle as q, AccessTopicPolicy as r, BucketPolicyName as s, AccessBucketPolicy as t, ClaimsMeta as u, FunctionSignature as v, ModelTypes as w, GeneratedColumns as x, FunctionTypes as y, TableFlags as z };