better-supabase 0.0.0 → 0.2.0

package/dist/index-DOsjFvMf.d.ts

@@ -0,0 +1,618 @@
+import { A as SchemaMeta, a as Casing, b as PermdockBucketPolicy, i as BucketPolicyName } from "./types-C83v5SQz.js";
+import { GeneratorMetadata, Queryable } from "@supabase/postgrest-typegen";
+//#region src/cli/introspect/types.d.ts
+/**
+ * What `better-supabase introspect` reads from Postgres. `generator` is the
+ * `@supabase/postgrest-typegen` contract (the same metadata behind
+ * `supabase gen types`); `extras` holds what that contract leaves out.
+ * Codegen and doctor both work from this snapshot, so either can run offline
+ * from a saved file.
+ */
+interface Snapshot {
+  readonly $schema?: string;
+  readonly version: 2;
+  /** Every schema that was read, including helper schemas for doctor. */
+  readonly schemas: readonly string[];
+  readonly generator: GeneratorMetadata;
+  readonly extras: SnapshotExtras;
+}
+/** Catalog details `GeneratorMetadata` does not carry. */
+interface SnapshotExtras {
+  readonly tables: readonly ExtrasTable[];
+  readonly buckets: readonly SnapshotBucket[];
+  /** Tables in the `supabase_realtime` publication, as `schema.table`. */
+  readonly realtime: readonly string[];
+  /**
+   * `alter role ... set` values for the Data API roles (`authenticator`),
+   * such as `pgrst.db_aggregates_enabled`. Absent in older snapshots.
+   */
+  readonly roleSettings?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  /**
+   * Functions that policies in the read schemas call, plus functions in
+   * those schemas with `set` options. Absent in older snapshots.
+   */
+  readonly functions?: readonly ExtrasFunction[];
+  /**
+   * The Postgres functions `supabase/config.toml` configures as Auth hooks,
+   * in any schema. Absent in older snapshots and without a `config.toml`.
+   */
+  readonly hooks?: readonly ExtrasHook[];
+}
+/** An `[auth.hook.<name>]` with a `pg-functions://` URI. */
+interface ExtrasHook {
+  /** `custom_access_token`, `send_email`, ... */
+  readonly hook: string;
+  readonly schema: string;
+  readonly name: string;
+  /** Every overload with that name; empty when the function does not exist. */
+  readonly functions: readonly ExtrasHookFunction[];
+}
+interface ExtrasHookFunction extends ExtrasFunction {
+  /**
+   * Of `supabase_auth_admin`, `authenticated` and `anon`, the roles that may
+   * execute it (directly or through `public`).
+   */
+  readonly execute: readonly string[];
+  /** Whether `public` may execute it (the default until revoked). */
+  readonly publicExecute: boolean;
+  /** Of the same roles, those with `usage` on its schema. */
+  readonly schemaUsage: readonly string[];
+  /** The function body (`pg_proc.prosrc`). Absent in snapshots that predate it. */
+  readonly source?: string;
+}
+/** A function as doctor needs it for RLS checks, in any schema. */
+interface ExtrasFunction {
+  readonly schema: string;
+  readonly name: string;
+  /** Identity arguments, e.g. `org uuid`. */
+  readonly signature: string;
+  /** `sql`, `plpgsql`, `c`, ... */
+  readonly language: string;
+  readonly volatility: "immutable" | "stable" | "volatile";
+  readonly securityDefiner: boolean;
+  /** `set` options, e.g. `{ statement_timeout: '5s' }`. */
+  readonly settings: Readonly<Record<string, string>>;
+}
+interface ExtrasTable {
+  /** Table oid, matching `GeneratorMetadata.tables[].id`. */
+  readonly id: number;
+  readonly schema: string;
+  readonly name: string;
+  /** Primary key columns in key order. */
+  readonly primaryKey: readonly string[];
+  readonly uniques: readonly CatalogUnique[];
+  readonly foreignKeys: readonly {
+    readonly name: string;
+    readonly onDelete: ForeignKeyAction;
+    readonly onUpdate: ForeignKeyAction;
+  }[];
+  readonly checks: readonly CatalogCheck[];
+  readonly indexes: readonly CatalogIndex[];
+  readonly policies: readonly CatalogPolicy[];
+  readonly triggers: readonly CatalogTrigger[];
+  readonly grants: readonly CatalogGrant[];
+  /** Postgres estimates at least `LARGE_TABLE_ROWS` rows; the `unbounded-read` lint reads it. */
+  readonly large?: true;
+}
+type ForeignKeyAction = "no action" | "restrict" | "cascade" | "set null" | "set default";
+interface CatalogUnique {
+  readonly name: string;
+  readonly columns: readonly string[];
+}
+interface CatalogCheck {
+  readonly name: string;
+  readonly definition: string;
+}
+interface CatalogIndex {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  readonly primary: boolean;
+  readonly partial: boolean;
+}
+interface CatalogPolicy {
+  readonly name: string;
+  readonly command: "all" | "select" | "insert" | "update" | "delete";
+  readonly roles: readonly string[];
+  readonly permissive: boolean;
+  readonly using: string | null;
+  readonly check: string | null;
+  /**
+   * Functions the policy expressions call, as `schema.name`, from
+   * `pg_depend`. Absent in older snapshots.
+   */
+  readonly functions?: readonly string[];
+}
+interface CatalogTrigger {
+  readonly name: string;
+  readonly timing: "before" | "after" | "instead of";
+  readonly events: readonly ("insert" | "update" | "delete" | "truncate")[];
+  readonly level: "row" | "statement";
+  readonly function: string;
+}
+interface CatalogGrant {
+  readonly role: string;
+  readonly privileges: readonly string[];
+}
+interface SnapshotBucket {
+  readonly id: string;
+  readonly public: boolean;
+  readonly fileSizeLimit: number | null;
+  readonly allowedMimeTypes: readonly string[] | null;
+}
+/**
+ * The snapshot joined into one record per table, function and enum. Codegen
+ * and doctor read this view rather than the raw snapshot.
+ */
+interface Catalog {
+  readonly schemas: readonly string[];
+  readonly tables: readonly CatalogTable[];
+  readonly enums: readonly CatalogEnum[];
+  readonly functions: readonly CatalogFunction[];
+  readonly buckets: readonly SnapshotBucket[];
+  readonly realtime: readonly string[];
+}
+interface CatalogTable {
+  readonly id: number;
+  readonly schema: string;
+  readonly name: string;
+  /** Materialized views count as views; foreign tables as tables. */
+  readonly kind: "table" | "view";
+  readonly rls: boolean;
+  readonly forceRls: boolean;
+  readonly replicaIdentity: "DEFAULT" | "INDEX" | "FULL" | "NOTHING" | null;
+  /** Inserts work (always true for tables). */
+  readonly insertable: boolean;
+  /** Updates work (always true for tables). */
+  readonly updatable: boolean;
+  readonly comment: string | null;
+  readonly columns: readonly CatalogColumn[];
+  readonly primaryKey: readonly string[];
+  readonly uniques: readonly CatalogUnique[];
+  readonly foreignKeys: readonly CatalogForeignKey[];
+  readonly checks: readonly CatalogCheck[];
+  readonly indexes: readonly CatalogIndex[];
+  readonly policies: readonly CatalogPolicy[];
+  readonly triggers: readonly CatalogTrigger[];
+  readonly grants: readonly CatalogGrant[];
+}
+interface CatalogColumn {
+  readonly name: string;
+  /** Type name; the element type for arrays (`uuid`, `int8`, `note_kind`). */
+  readonly udt: string;
+  /** Raw type name as Postgres reports it (`_text` for `text[]`). */
+  readonly format: string;
+  readonly typeSchema: string;
+  readonly isArray: boolean;
+  readonly isEnum: boolean;
+  readonly nullable: boolean;
+  readonly hasDefault: boolean;
+  readonly default: string | null;
+  readonly identity: "always" | "by default" | null;
+  readonly generated: boolean;
+  readonly updatable: boolean;
+  readonly comment: string | null;
+}
+interface CatalogForeignKey {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly refSchema: string;
+  readonly refTable: string;
+  readonly refColumns: readonly string[];
+  readonly oneToOne: boolean;
+  readonly onDelete: ForeignKeyAction;
+  readonly onUpdate: ForeignKeyAction;
+}
+interface CatalogEnum {
+  readonly schema: string;
+  readonly name: string;
+  readonly values: readonly string[];
+}
+interface CatalogFunction {
+  readonly schema: string;
+  readonly name: string;
+  /** Signature that tells overloads apart, e.g. `a integer, b text`. */
+  readonly signature: string;
+  readonly args: readonly CatalogFunctionArg[];
+  /** Columns for `returns table (...)` functions. */
+  readonly returnsTable: readonly {
+    readonly name: string;
+    readonly udt: string;
+  }[] | null;
+  /** Return type name (`int4`, `_text`, a table's row type). */
+  readonly returns: string;
+  /** `schema.table` when the function returns rows of a table or view. */
+  readonly returnsRelation: string | null;
+  readonly returnsSet: boolean;
+  readonly volatility: "immutable" | "stable" | "volatile";
+  readonly securityDefiner: boolean;
+  readonly language: string;
+  /** `search_path` from `SET search_path`, or `null` when unset. */
+  readonly searchPath: string | null;
+}
+interface CatalogFunctionArg {
+  readonly name: string;
+  readonly udt: string;
+  readonly isArray: boolean;
+  readonly hasDefault: boolean;
+}
+//#endregion
+//#region src/generators/shared.d.ts
+/** What field planning reads: the metadata and the typed-jsonb config. */
+interface SchemaSource {
+  readonly meta: SchemaMeta;
+  readonly config: {
+    readonly json: Readonly<Record<string, unknown>>;
+  };
+}
+//#endregion
+//#region src/generators/json-schema.d.ts
+interface JsonSchemaGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.schema.json`. */
+  readonly output?: string;
+  /** `$id` of the document. */
+  readonly id?: string;
+}
+type JsonSchema = Record<string, unknown>;
+/** JSON Schema (2020-12) `$defs` for every table: `customersRow`, `customersInsert`, ... */
+declare function buildJsonSchema(input: SchemaSource, id?: string): JsonSchema;
+/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
+declare function jsonSchema(options?: JsonSchemaGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/valibot.d.ts
+interface ValibotGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.valibot.ts`. */
+  readonly output?: string;
+  /** Schemas for typed jsonb columns: `{ 'customers.metadata': './schemas.ts#metadata' }`. */
+  readonly json?: Readonly<Record<string, string>>;
+}
+/** Valibot schemas for every table's Row, Insert and Update shape. */
+declare function valibot(options?: ValibotGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/zod.d.ts
+interface ZodGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.zod.ts`. */
+  readonly output?: string;
+  /** Schemas for typed jsonb columns: `{ 'customers.metadata': './schemas.ts#metadata' }`. */
+  readonly json?: Readonly<Record<string, string>>;
+}
+/** Zod 4 schemas for every table's Row, Insert and Update shape. */
+declare function zod(options?: ZodGeneratorOptions): Generator;
+//#endregion
+//#region src/config/index.d.ts
+/**
+ * Where codegen reads the database from. Without any of these, `$DATABASE_URL`
+ * and then the local stack (`supabase start`) are used.
+ */
+interface SourceConfig {
+  /** Postgres connection string. */
+  readonly dbUrl?: string;
+  /**
+   * Hosted project ref. Read through the Management API's read-only SQL
+   * endpoint, so no database password is needed.
+   */
+  readonly projectRef?: string;
+  /**
+   * Management API token for `projectRef`. Defaults to
+   * `$SUPABASE_ACCESS_TOKEN`; prefer the env var over committing a token.
+   */
+  readonly accessToken?: string;
+  /** Read a saved `better-supabase introspect` snapshot instead of connecting. */
+  readonly snapshot?: string;
+}
+/**
+ * A JSON Schema object, or a Standard JSON Schema value (zod 4, valibot,
+ * arktype, ...) that can produce one.
+ */
+type JsonSchemaSource = Readonly<Record<string, unknown>> | {
+  readonly "~standard": {
+    readonly jsonSchema: {
+      readonly input: (options: {
+        readonly target: string;
+      }) => Record<string, unknown>;
+    };
+  };
+};
+type JsonTypeConfig = ({
+  readonly import: string;
+} | {
+  readonly type: string;
+}) & {
+  /** Enforced in the database by `sql add jsonb-schemas` (pg_jsonschema). */
+  readonly schema?: JsonSchemaSource;
+};
+/** The JSON Schema document for a `json[...].schema` entry. */
+declare function resolveJsonSchema(source: JsonSchemaSource): Readonly<Record<string, unknown>>;
+interface TableConfig {
+  readonly casing?: Casing;
+  /** Leave the table out of the generated models. */
+  readonly exclude?: boolean;
+  /** Rename generated relations: `{ primaryContact: 'contact' }`. */
+  readonly relations?: Readonly<Record<string, string>>;
+}
+interface TimestampsConfig {
+  readonly createdAt?: string;
+  readonly updatedAt?: string;
+}
+interface SoftDeleteConfig {
+  readonly column?: string;
+}
+interface TenantConfig {
+  readonly column?: string;
+}
+/**
+ * Claim names shared by the SQL kit, codegen and the runtime defaults. They
+ * follow PermDock's claim contract.
+ */
+interface ClaimsConfig {
+  /** Top-level claim holding the active tenant id. Defaults to `tenant_id`. */
+  readonly tenant?: string;
+  /** `scope` of the tenant entries `membership_claims()` writes. Defaults to `tenant`. */
+  readonly scope?: string;
+  /** Claim holding plan features per tenant (`{ [tenantId]: string[] }`). Defaults to `features`. */
+  readonly features?: string;
+}
+interface ActorConfig {
+  readonly createdBy?: string;
+  readonly updatedBy?: string;
+}
+interface PluginFlagsConfig {
+  readonly timestamps?: boolean | TimestampsConfig;
+  readonly softDelete?: boolean | SoftDeleteConfig;
+  readonly tenant?: boolean | TenantConfig;
+  readonly actor?: boolean | ActorConfig;
+}
+interface BucketConfig {
+  readonly id?: string;
+  readonly public?: boolean;
+  /** Path template with `{placeholders}`, e.g. `{orgId}/{customerId}/logo.webp`. */
+  readonly path: string;
+  /** Generated storage policy, or a PermDock policy (`{ permdock, scope }`). */
+  readonly policy?: BucketPolicyName | PermdockBucketPolicy;
+  readonly fileSizeLimit?: string;
+  readonly allowedMimeTypes?: readonly string[];
+}
+interface SqlConfig {
+  /** Directory declarative schema files are written to. */
+  readonly dir?: string;
+  /** File name prefix, so generated files sort after yours. */
+  readonly prefix?: string;
+  /** Directory pgTAP files (the `pgtap` module) are written to. */
+  readonly testsDir?: string;
+  /** SQL kit modules to keep in sync (`better-supabase sql add`). */
+  readonly kit?: readonly string[];
+}
+interface SeedConfig {
+  /** Module exporting `defineSeed(...)` as `seed` or default. */
+  readonly entry?: string;
+  /** SQL file `better-supabase seed` writes. Add it to `[db.seed] sql_paths`. */
+  readonly output?: string;
+}
+interface OpenApiConfig {
+  /** Module exporting the document (or a function returning it) as `openapi` or default. */
+  readonly entry?: string;
+  /** JSON file `better-supabase openapi emit` writes. */
+  readonly output?: string;
+}
+interface DoctorConfig {
+  /** Finding codes to skip, e.g. `['BS204']`. */
+  readonly ignore?: readonly string[];
+  /** Treat warnings as errors. */
+  readonly strict?: boolean;
+  /**
+   * App source files doctor scans for API use (BS210). Globs relative to the
+   * root. Defaults to `['src/**\/*.{ts,tsx}']`.
+   */
+  readonly sources?: readonly string[];
+  /**
+   * How many policies a security definer helper may appear in before BS206
+   * asks for an inlinable `language sql stable` function. Defaults to 5.
+   */
+  readonly policyHelperLimit?: number;
+  /**
+   * The BS405 limit in bytes. With a `permdock.config.ts` it is PermDock's
+   * budget for `memberships` plus `attrs` (default 1024, matching
+   * `supabase.hook.budget`) and the whole token keeps 2048. Without one it
+   * limits the whole token's claims (default 2048).
+   */
+  readonly claimsLimit?: number;
+}
+/**
+ * Runtime types for columns whose JSON form loses information. Defaults
+ * match `supabase gen types`: timestamps as ISO strings, `int8` and
+ * `numeric` as numbers.
+ */
+interface CodecsConfig {
+  /** `'date'` decodes `timestamptz`/`timestamp` columns to `Date`. */
+  readonly timestamptz?: "string" | "date";
+  /** `'bigint'` or `'string'` read `int8` exactly (above 2^53). */
+  readonly int8?: "number" | "string" | "bigint";
+  /** `'string'` reads `numeric` exactly. */
+  readonly numeric?: "number" | "string";
+}
+interface GeneratedFile {
+  /** Path relative to the project root. */
+  readonly path: string;
+  readonly contents: string;
+}
+interface GeneratorInput {
+  readonly meta: SchemaMeta;
+  /**
+   * The `@supabase/postgrest-typegen` metadata for the configured schemas,
+   * the same contract `supabase gen types` is built on.
+   */
+  readonly introspection: GeneratorMetadata;
+  /** Constraints, indexes, policies, triggers and grants typegen leaves out. */
+  readonly extras: SnapshotExtras;
+  readonly config: ResolvedConfig;
+  /** Absolute path of the main generated module. */
+  readonly output: string;
+  /** Import path from `from` (a generated file) to `to`, with extension. */
+  readonly importPath: (from: string, to: string) => string;
+}
+/**
+ * Codegen extension point. First-party generators: `zod()`, `valibot()`,
+ * `jsonSchema()`. Prove custom ones with `testGenerator`.
+ */
+interface Generator {
+  readonly name: string;
+  generate(input: GeneratorInput): readonly GeneratedFile[] | Promise<readonly GeneratedFile[]>;
+}
+interface RealtimeConfig {
+  /**
+   * Tables that broadcast a change signal for live queries (`table` or
+   * `schema.table`). Tenant tables broadcast per tenant. Install the
+   * triggers with `better-supabase sql add realtime-tables`.
+   */
+  readonly tables?: readonly string[];
+}
+interface EntitlementsConfig {
+  /**
+   * `table.column` (or `schema.table.column`) holding each tenant's Stripe
+   * customer id, read by the `entitlements` SQL kit module. Defaults to
+   * `organizations.stripe_customer_id`.
+   */
+  readonly customer?: string;
+  /** The tenant id column of that table. Defaults to `id`. */
+  readonly key?: string;
+}
+/** pgvector distance: `<=>` (cosine), `<->` (l2) or `<#>` (negative inner product). */
+type VectorDistance = "cosine" | "l2" | "inner_product";
+/** The embedding column, or the column and its distance (default `cosine`). */
+type VectorSearchConfig = string | {
+  readonly column: string;
+  readonly distance?: VectorDistance;
+};
+/** A privilege the Data API roles can be granted on a table or view. */
+type Privilege = "select" | "insert" | "update" | "delete";
+/**
+ * Data API grants for one table: privileges for `authenticated`, or per
+ * role.
+ */
+type ExposeConfig = readonly Privilege[] | {
+  readonly anon?: readonly Privilege[];
+  readonly authenticated?: readonly Privilege[];
+};
+/** Resolved grants for one table. */
+interface ResolvedExpose {
+  readonly anon: readonly Privilege[];
+  readonly authenticated: readonly Privilege[];
+}
+interface BetterSupabaseConfig {
+  readonly $schema?: string;
+  readonly source?: SourceConfig;
+  /** Postgres schemas to generate. Defaults to `['public']`. */
+  readonly schemas?: readonly string[];
+  /** Casing of generated models and returned rows. Defaults to `'snake'`. */
+  readonly casing?: Casing;
+  readonly tables?: Readonly<Record<string, TableConfig>>;
+  /**
+   * Main generated module. Defaults to `src/lib/supabase/generated.ts`;
+   * `database.types.ts` is written next to it.
+   */
+  readonly output?: string;
+  /**
+   * PostgREST major version, written to `__InternalSupabase` in
+   * `database.types.ts` so `createClient` picks matching behavior.
+   * Defaults to `'13'`.
+   */
+  readonly postgrestVersion?: string;
+  /** Types for jsonb columns, keyed by `table.column`. */
+  readonly json?: Readonly<Record<string, JsonTypeConfig>>;
+  readonly codecs?: CodecsConfig;
+  /**
+   * Columns that must not be read by accident (`table.column` or
+   * `schema.table.column`, database names), for the `noSensitiveSelect` rule.
+   */
+  readonly sensitive?: readonly string[];
+  /**
+   * Text columns that hold an object path, keyed by `table.column` or
+   * `schema.table.column` (database names), with the bucket as the value (a
+   * `buckets` key or a bucket id). Generated rows type them as
+   * `StoragePath<'bucket-id'>`.
+   */
+  readonly storagePaths?: Readonly<Record<string, string>>;
+  /**
+   * Data API grants, keyed by `table` or `schema.table`. Supabase no longer
+   * grants new tables to `anon` and `authenticated` automatically; the
+   * `grants` SQL kit module writes these, and doctor (BS106) checks them.
+   * Tables not listed need `select, insert, update, delete` for
+   * `authenticated` (`select` for views).
+   */
+  readonly expose?: Readonly<Record<string, ExposeConfig>>;
+  /**
+   * Modules that export `defineReadSet` results. `gen` compiles each set to
+   * a function in the `read-sets` SQL kit module. Node imports them, so
+   * relative imports need their `.ts` extension.
+   */
+  readonly readSets?: readonly string[];
+  readonly generators?: readonly Generator[];
+  /** Enables plugin flags in the generated metadata. */
+  readonly plugins?: PluginFlagsConfig;
+  readonly claims?: ClaimsConfig;
+  readonly buckets?: Readonly<Record<string, BucketConfig>>;
+  /** Realtime topic templates: `{ notifications: 'org:{orgId}:notifications' }`. */
+  readonly topics?: Readonly<Record<string, string>>;
+  readonly realtime?: RealtimeConfig;
+  readonly entitlements?: EntitlementsConfig;
+  /**
+   * Embedding columns, keyed by `table` or `schema.table`. The
+   * `vector-search` SQL kit module writes `search_<table>(query, k)` for each,
+   * which `db.$search(table, { vector, k })` calls.
+   */
+  readonly vectorSearch?: Readonly<Record<string, VectorSearchConfig>>;
+  readonly sql?: SqlConfig;
+  readonly seed?: SeedConfig;
+  readonly openapi?: OpenApiConfig;
+  readonly doctor?: DoctorConfig;
+}
+/** The config with defaults applied. */
+interface ResolvedConfig {
+  readonly root: string;
+  readonly source: SourceConfig;
+  readonly schemas: readonly string[];
+  readonly casing: Casing;
+  readonly tables: Readonly<Record<string, TableConfig>>;
+  readonly output: string;
+  /** `database.types.ts` next to `output`. */
+  readonly databaseTypesOutput: string;
+  readonly postgrestVersion: string;
+  readonly json: Readonly<Record<string, JsonTypeConfig>>;
+  readonly codecs: Required<CodecsConfig>;
+  readonly sensitive: readonly string[];
+  readonly storagePaths: Readonly<Record<string, string>>;
+  readonly expose: Readonly<Record<string, ResolvedExpose>>;
+  readonly readSets: readonly string[];
+  readonly generators: readonly Generator[];
+  readonly plugins: {
+    readonly timestamps: Required<TimestampsConfig> | undefined;
+    readonly softDelete: Required<SoftDeleteConfig> | undefined;
+    readonly tenant: Required<TenantConfig> | undefined;
+    readonly actor: Required<ActorConfig> | undefined;
+  };
+  readonly claims: Required<ClaimsConfig>;
+  readonly buckets: Readonly<Record<string, BucketConfig>>;
+  readonly entitlements: {
+    readonly table: string;
+    readonly column: string;
+    readonly key: string;
+  };
+  readonly vectorSearch: readonly {
+    readonly table: string;
+    readonly column: string;
+    readonly distance: VectorDistance;
+  }[];
+  readonly topics: Readonly<Record<string, string>>;
+  readonly realtime: Required<RealtimeConfig>;
+  readonly sql: Required<SqlConfig>;
+  readonly seed: Required<SeedConfig>;
+  readonly openapi: Required<OpenApiConfig>;
+  readonly doctor: Required<Omit<DoctorConfig, "claimsLimit">> & Pick<DoctorConfig, "claimsLimit">;
+}
+declare const CONFIG_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/config-v1.json";
+/** Identity helper that types `better-supabase.config.ts`. */
+declare function defineConfig(config: BetterSupabaseConfig): BetterSupabaseConfig;
+/** Applies defaults. Paths stay relative to `root`. */
+declare function resolveConfig(config: BetterSupabaseConfig, root: string): ResolvedConfig;
+//#endregion
+export { ExtrasFunction as $, defineConfig as A, Catalog as B, SourceConfig as C, TimestampsConfig as D, TenantConfig as E, ValibotGeneratorOptions as F, CatalogFunction as G, CatalogColumn as H, valibot as I, CatalogIndex as J, CatalogFunctionArg as K, JsonSchemaGeneratorOptions as L, resolveJsonSchema as M, ZodGeneratorOptions as N, VectorDistance as O, zod as P, CatalogUnique as Q, buildJsonSchema as R, SoftDeleteConfig as S, TableConfig as T, CatalogEnum as U, CatalogCheck as V, CatalogForeignKey as W, CatalogTable as X, CatalogPolicy as Y, CatalogTrigger as Z, Privilege as _, ClaimsConfig as a, SnapshotBucket as at, ResolvedExpose as b, EntitlementsConfig as c, Queryable as ct, Generator as d, ExtrasHook as et, GeneratorInput as f, PluginFlagsConfig as g, OpenApiConfig as h, CONFIG_SCHEMA_URL as i, Snapshot as it, resolveConfig as j, VectorSearchConfig as k, ExposeConfig as l, JsonTypeConfig as m, BetterSupabaseConfig as n, ExtrasTable as nt, CodecsConfig as o, SnapshotExtras as ot, JsonSchemaSource as p, CatalogGrant as q, BucketConfig as r, ForeignKeyAction as rt, DoctorConfig as s, GeneratorMetadata as st, ActorConfig as t, ExtrasHookFunction as tt, GeneratedFile as u, RealtimeConfig as v, SqlConfig as w, SeedConfig as x, ResolvedConfig as y, jsonSchema as z };

package/dist/index-DbxFr7XG.d.ts

@@ -0,0 +1,76 @@
+import { A as SchemaMeta } from "./types-C83v5SQz.js";
+import { f as OpenApiParameter } from "./index-Bw1bwtC0.js";
+//#region src/openapi/index.d.ts
+type Json = Record<string, unknown>;
+type ResourceOperation = "list" | "get" | "create" | "update" | "delete";
+interface ResourceOptions {
+  /** Defaults to every operation for tables, `list` and `get` for views. */
+  readonly operations?: readonly ResourceOperation[];
+  /** Parameters for `list`, from `defineListQuery`. */
+  readonly list?: {
+    readonly openapi: readonly OpenApiParameter[];
+  };
+  /** Path of the collection. Defaults to `/<table>`. */
+  readonly path?: string;
+  readonly tag?: string;
+  readonly description?: string;
+}
+interface OpenApiOptions {
+  readonly info: {
+    readonly title: string;
+    readonly version: string;
+    readonly description?: string;
+  };
+  readonly servers?: readonly {
+    readonly url: string;
+    readonly description?: string;
+  }[];
+  /** Prefix for every path, e.g. `/api`. */
+  readonly basePath?: string;
+  /** Tables to publish, by app key. */
+  readonly resources: Readonly<Record<string, ResourceOptions | true>>;
+  /**
+   * Security schemes. `bearer` is a Supabase access token; `oauth2` uses the
+   * Supabase OAuth server and needs `supabaseUrl`. Defaults to `['bearer']`.
+   */
+  readonly security?: readonly ("bearer" | "oauth2")[];
+  readonly supabaseUrl?: string;
+  /** Tables with a JSON column typed in `better-supabase.config.ts`. */
+  readonly json?: Readonly<Record<string, unknown>>;
+}
+interface OpenApiDocument {
+  readonly openapi: string;
+  readonly info: OpenApiOptions["info"];
+  readonly jsonSchemaDialect: string;
+  readonly servers?: OpenApiOptions["servers"];
+  readonly tags: readonly {
+    readonly name: string;
+    readonly description?: string;
+  }[];
+  readonly paths: Readonly<Record<string, Json>>;
+  readonly components: {
+    readonly schemas: Readonly<Record<string, Json>>;
+    readonly responses: Readonly<Record<string, Json>>;
+    readonly securitySchemes: Readonly<Record<string, Json>>;
+  };
+  readonly security: readonly Readonly<Record<string, readonly string[]>>[];
+}
+/** JSON Schema for RFC 9457 Problem Details as better-supabase sends them. */
+declare const PROBLEM_SCHEMA: Json;
+/**
+ * An OpenAPI 3.1 document for REST resources over your tables, with schemas
+ * from the generated metadata, list-query parameters, Supabase security
+ * schemes and Problem Details errors.
+ *
+ * ```ts
+ * const doc = createOpenApi(sb, {
+ *   info: { title: 'CRM API', version: '1.0.0' },
+ *   resources: { customers: { list: customerList }, notes: { operations: ['list', 'get'] } },
+ * });
+ * ```
+ */
+declare function createOpenApi(sb: {
+  readonly meta: SchemaMeta;
+}, options: OpenApiOptions): OpenApiDocument;
+//#endregion
+export { ResourceOptions as a, ResourceOperation as i, OpenApiOptions as n, createOpenApi as o, PROBLEM_SCHEMA as r, OpenApiDocument as t };