better-supabase 0.13.0 → 0.14.0

package/dist/index-CxZQgNVE.d.ts

@@ -0,0 +1,62 @@
+import { _ as OpenApiDocuments, b as OpenApiVersion, l as AnyOpenApiDocument, n as DefineApiOptions, x as RenderedOpenApi } from "./api-CWhpq24a.js";
+import { c as SpecDiagnostic, r as DocumentFormat } from "./format-AYHceC2m.js";
+import { r as ResourceDescription } from "./resource-DYDEnww-.js";
+import { n as ApiSource } from "./options-Dm-2crCx.js";
+//#region src/openapi/format.d.ts
+/**
+ * OpenAPI as a `DocumentFormat`. 3.1 is the default; 3.0 is legacy (schemas
+ * lowered to the 3.0 Schema Object); 3.2 has native `$self`, nested tags,
+ * `itemSchema`, `oauth2MetadataUrl` and `query`; `3.3-preview` follows the
+ * v3.3-dev branch at `SPEC_PINS.openapi33Preview`, with Path Item `security`
+ * and the Security Profiles proposal. Below 3.2, the 3.2 fields travel as the
+ * registered `x-oai-*` extensions where one exists, and as the model's prefixed
+ * extensions otherwise.
+ */
+declare const openapiFormat: DocumentFormat<"openapi", OpenApiVersion, AnyOpenApiDocument, OpenApiDocuments>;
+//#endregion
+//#region src/openapi/schema30.d.ts
+type Json = Record<string, unknown>;
+/**
+ * Rewrites a JSON Schema 2020-12 schema into the OpenAPI 3.0 Schema Object:
+ * `null` in `type` or in an `anyOf`/`oneOf` becomes `nullable`, a type list
+ * becomes `anyOf`, `const` becomes a one-value `enum`, `examples` becomes
+ * `example`, numeric `exclusiveMinimum`/`exclusiveMaximum` become the boolean
+ * form, `contentEncoding: base64` becomes `format: byte`, and a `$ref` with
+ * siblings is wrapped in `allOf`. Keywords 3.0 does not have are left out. The
+ * input is not changed.
+ */
+declare function toOpenApi30Schema(schema: Readonly<Json>): Json;
+//#endregion
+//#region src/openapi/index.d.ts
+/** How one table is published; see `defineApi`'s `resources`. */
+type ResourceOptions<Ref = string> = ResourceDescription<Ref>;
+interface OpenApiOptions<V extends OpenApiVersion = "3.1", Ref = string> extends DefineApiOptions<Ref> {
+  /** Defaults to 3.1. `3.3-preview` follows a draft. */
+  readonly version?: V;
+  /** Last change to the document before overlays; see `RenderOptions.transform`. */
+  readonly transform?: (rendered: Extract<RenderedOpenApi, {
+    readonly version: V;
+  }>) => OpenApiDocuments[OpenApiVersion] | undefined;
+  readonly overlays?: readonly unknown[];
+  /** Hears every warning and info finding. Errors throw. */
+  readonly onDiagnostic?: (diagnostic: SpecDiagnostic) => void;
+}
+/**
+ * An OpenAPI document for REST resources over your tables, with schemas from
+ * the generated metadata, list-query parameters, Supabase security schemes and
+ * Problem Details errors. Throws when building or checking the document finds
+ * an error; use `defineApi` to read every finding instead.
+ *
+ * ```ts
+ * const doc = createOpenApi(betterSupabase, {
+ *   info: { title: "CRM API", version: "1.0.0" },
+ *   resources: {
+ *     customers: { list: customerList },
+ *     notes: { operations: ["list", "get"] },
+ *   },
+ * });
+ * ```
+ */
+declare function createOpenApi<V extends OpenApiVersion = "3.1", Ref = string>(betterSupabase: ApiSource, options: OpenApiOptions<V, Ref>): OpenApiDocuments[V];
+//#endregion
+export { openapiFormat as a, toOpenApi30Schema as i, ResourceOptions as n, createOpenApi as r, OpenApiOptions as t };

package/dist/index-D4420jLW.d.ts

@@ -0,0 +1,66 @@
+import { h as MutationIntent, lt as SchemaMeta } from "./executor-CPyrQdjh.js";
+import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, c as MutationNotice, k as BlockEventsMatching, o as EventHub } from "./events-DbLjvxDX.js";
+import { i as EventSink, n as CloudEventOptions, t as CloudEvent } from "./cloud-event-SPyXMdcd.js";
+//#region src/core/block-event-listener.d.ts
+/**
+ * Listens to the block events that match `pattern` (`'support.started'` or
+ * `'support.*'`), typed by `events`: a block's events, `defineBlocks(...)` or
+ * `defineEvents(...)`. Returns a function that stops listening.
+ */
+declare function onBlockEvent<M extends EventMap, const P extends BlockEventPattern<M>>(betterSupabase: {
+  readonly events: EventHub;
+}, events: Events<M>, pattern: P, handler: (event: BlockEvent<M, BlockEventsMatching<M, P>>) => void): () => void;
+//#endregion
+//#region src/events/index.d.ts
+declare const ROW_EVENT_TYPES: { readonly [K in MutationIntent]: string; };
+interface RowEventData {
+  readonly table: string;
+  readonly row: Readonly<Record<string, unknown>>;
+  readonly actorId?: string;
+}
+/**
+ * One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
+ * app-cased row and the actor in `data`, the primary key as `subject` and the
+ * tenant as `partitionkey`. Writes that return no rows (soft deletes,
+ * `returning: false`) send one event per known primary key, with the key as
+ * `row`.
+ */
+declare function toCloudEvents(notice: MutationNotice, options: CloudEventOptions & {
+  readonly meta?: SchemaMeta;
+}): CloudEvent<RowEventData>[];
+interface ForwardOptions extends CloudEventOptions {
+  /** Only forward these tables or kinds. */
+  readonly filter?: (notice: MutationNotice) => boolean;
+  /** Sink failures never fail the mutation. Defaults to the `Logger`. */
+  readonly onError?: (error: unknown, events: readonly CloudEvent[]) => void;
+}
+/**
+ * Sends a CloudEvent for every mutation to `sink`. Returns a function that
+ * stops forwarding. Sends in flight are tracked on `betterSupabase.events`
+ * (`settled()`), which the Next adapter hands to `after()` and the edge entry
+ * to `waitUntil`. Use an outbox (SQL modules) when events must not be lost.
+ */
+declare function forwardMutations(betterSupabase: {
+  readonly events: EventHub;
+  readonly meta: SchemaMeta;
+}, sink: EventSink, options: ForwardOptions): () => void;
+type HttpMode = "structured" | "binary" | "batch";
+/** The HTTP protocol binding: headers and body for one event (or a batch). */
+declare function toHttp(events: CloudEvent | readonly CloudEvent[], mode?: HttpMode): {
+  headers: Record<string, string>;
+  body: string;
+}[];
+declare function isCloudEvent(value: unknown): value is CloudEvent;
+/** Reads CloudEvents from a request in any of the three HTTP modes. */
+declare function fromHttp(request: Request): Promise<CloudEvent[]>;
+interface HttpSinkOptions {
+  readonly mode?: HttpMode;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly fetch?: typeof fetch;
+  /** Abort a request that takes longer than this. Defaults to 10 seconds. */
+  readonly timeoutMs?: number;
+}
+/** POSTs events to `url`. Non-2xx responses and timeouts reject. */
+declare function httpSink(url: string | URL, options?: HttpSinkOptions): EventSink;
+//#endregion
+export { RowEventData as a, httpSink as c, toHttp as d, onBlockEvent as f, ROW_EVENT_TYPES as i, isCloudEvent as l, HttpMode as n, forwardMutations as o, HttpSinkOptions as r, fromHttp as s, ForwardOptions as t, toCloudEvents as u };

package/dist/index-DK-YTWLd.d.ts

@@ -0,0 +1,443 @@
+import { R as ClaimsMeta, lt as SchemaMeta } from "./executor-CPyrQdjh.js";
+import { A as BlockNameRegistry, k as TablesOf, p as AnyBlocksConfig } from "./authorization-BuT26_sR.js";
+import { hn as EntityRename, mn as EntityNoun } from "./define-block-COpcS6aT.js";
+import { a as ScalarKind, i as FieldSpec } from "./table-schema-Cb-IV_pZ.js";
+import { C as Generator, J as ResolvedConfig, K as BetterSupabaseConfig, L as JsonSchemaSource, n as ExpandedConfig, xt as AppOnDeleteAction } from "./config-BuOz_O-y.js";
+//#region src/config/defaults.d.ts
+/**
+ * Every default `resolveConfig` fills in. Other modules (the SQL module
+ * registry, the CLI) read their fallbacks from here instead of repeating the
+ * literals.
+ */
+declare const CONFIG_DEFAULTS: {
+  readonly output: string;
+  readonly schemas: readonly string[];
+  readonly casing: "snake";
+  readonly postgrestVersion: string;
+  readonly codecs: {
+    readonly timestamptz: "string";
+    readonly int8: "number";
+    readonly numeric: "number";
+  };
+  readonly sql: {
+    readonly dir: string;
+    readonly prefix: string;
+    readonly testsDir: string;
+  };
+  readonly seed: {
+    readonly entry: string;
+    readonly output: string;
+    readonly perTenant: string;
+  };
+  readonly openapi: {
+    readonly entry: string;
+    readonly output: string;
+  };
+  readonly specs: {
+    readonly failOn: "error";
+  };
+  readonly doctor: {
+    readonly format: "text";
+    readonly sources: readonly string[];
+    readonly policyHelperLimit: number;
+  };
+  readonly gen: {
+    readonly watchInterval: number;
+  };
+  readonly env: {
+    readonly output: string;
+  };
+};
+//#endregion
+//#region src/config/json.d.ts
+/**
+ * The JSON Schema document for a `json[...].schema` entry. A Standard Schema
+ * converts for `target` (2020-12 by default); a JSON Schema object is returned
+ * as it is.
+ */
+declare function resolveJsonSchema(source: JsonSchemaSource, target?: "draft-2020-12" | "draft-07" | "openapi-3.0"): Readonly<Record<string, unknown>>;
+//#endregion
+//#region src/config/references.d.ts
+/**
+ * A logical table of a block the registry knows, as `appTables` columns
+ * reference it: `{ block: "work-items", table: "items" }`.
+ */
+type BlockTableReference = { readonly [M in keyof BlockNameRegistry]: {
+  readonly block: M;
+  readonly table: TablesOf<M>;
+}; }[keyof BlockNameRegistry];
+type AppTablesOf<C> = C extends {
+  readonly appTables: infer T extends object;
+} ? T : Record<never, never>;
+/** The app tables a literal config declares, or `string` without any. */
+type AppTableNames<C> = [keyof AppTablesOf<C>] extends [never] ? string : (keyof AppTablesOf<C> & string) | "auth.users";
+/** What a column of `C`'s app tables may reference. */
+type TypedReference<C> = ({
+  readonly table: AppTableNames<C>;
+} | BlockTableReference) & {
+  readonly onDelete?: AppOnDeleteAction;
+};
+type ColumnsOfTable<T> = T extends {
+  readonly columns: infer K extends object;
+} ? K : Record<never, never>;
+type AppTableReferences<C> = { readonly [T in keyof AppTablesOf<C>]?: {
+  readonly columns?: { readonly [K in keyof ColumnsOfTable<AppTablesOf<C>[T]>]?: ColumnsOfTable<AppTablesOf<C>[T]>[K] extends {
+    readonly references: unknown;
+  } ? {
+    readonly references?: TypedReference<C>;
+  } : unknown; };
+}; };
+type RolesOf<C> = C extends {
+  readonly blocks: {
+    readonly access: {
+      readonly roles: infer R extends object;
+    };
+  };
+} ? keyof R & string : never;
+/**
+ * The roles `blocks.access.roles` declares, or `string` when the config leaves
+ * them to the default list or another access model.
+ */
+type RoleNames<C> = [RolesOf<C>] extends [never] ? string : RolesOf<C>;
+type BucketsOf<C> = C extends {
+  readonly buckets: infer B extends object;
+} ? keyof B & string : never;
+/**
+ * A bucket `storagePaths` names: a `buckets` key, suggested first, or the id of
+ * a bucket the config doesn't declare.
+ */
+type BucketName<C> = BucketsOf<C> | (string & {});
+type RoleReferences<C> = [RolesOf<C>] extends [never] ? unknown : {
+  readonly blocks?: {
+    readonly sso?: {
+      readonly options?: {
+        readonly defaultRole?: RoleNames<C>;
+        readonly roleOrder?: readonly RoleNames<C>[];
+      };
+    };
+    readonly billing?: {
+      readonly options?: {
+        readonly seatRoles?: readonly RoleNames<C>[];
+      };
+    };
+  };
+};
+/**
+ * What `defineConfig` checks a literal config against: block tables in
+ * `appTables` references, app table names, bucket names in `storagePaths`, and
+ * the role names other blocks take from `blocks.access.roles`.
+ */
+type ConfigReferences<C> = {
+  readonly appTables?: AppTableReferences<C>;
+  readonly storagePaths?: Readonly<Record<string, BucketName<C>>>;
+} & RoleReferences<C>;
+//#endregion
+//#region src/config/resolve.d.ts
+declare const CONFIG_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/config-v1.json";
+/**
+ * Types `better-supabase.config.ts` and returns it with its literal types. With
+ * `preset`, it expands the preset into `blocks` and its conventions first, and
+ * the keys you set win. It checks the references between keys against the
+ * config itself: block tables and app tables in `appTables` references, the
+ * `buckets` in `storagePaths`, and the `blocks.access.roles` other blocks
+ * name.
+ */
+declare function defineConfig<const C extends BetterSupabaseConfig>(config: C & NoInfer<ConfigReferences<C>>): ExpandedConfig<C>;
+/** Applies defaults. Paths stay relative to `root`. */
+declare function resolveConfig(input: BetterSupabaseConfig, root: string): ResolvedConfig;
+//#endregion
+//#region src/config/block-subjects.d.ts
+/**
+ * The entities `blocks.<module>.entities` gives a new name, such as `work_item`
+ * to `task`, for the block's TypeScript client (`blocks.generated.ts`). Empty
+ * when the module renames none.
+ */
+declare function blockEntityRenames(module: string, blocks: AnyBlocksConfig): readonly EntityRename[];
+/** One installed block's entity under the name the config gives it. */
+interface BlockEntity {
+  /** The entity's key in the block's manifest: its default singular noun. */
+  readonly key: string;
+  readonly from: EntityNoun;
+  readonly to: EntityNoun;
+  readonly primary: boolean;
+  /**
+   * The table that holds it as the SQL writes it (`tasks`, or the
+   * `blocks.<name>.tables` mapping), or undefined when it has none.
+   */
+  readonly table: string | undefined;
+  /** `blocks.<name>.entities.<entity>.url`, with column placeholders. */
+  readonly url: string | undefined;
+}
+/** The entities one installed block declares, with their final names. */
+declare function blockEntities(module: string, blocks: AnyBlocksConfig): readonly BlockEntity[];
+/**
+ * The entities of every installed block that registers one (work items, deals,
+ * companies and people, products, employees), under their renamed type, then
+ * `subjects`. Throws when `subjects` already has a block's type.
+ */
+/** The subject types one installed block registers, by renamed entity. */
+declare function blockSubjectTypes(module: string, blocks: AnyBlocksConfig): readonly string[];
+//#endregion
+//#region src/core/claims.d.ts
+declare const DEFAULT_CLAIMS: ClaimsMeta;
+/**
+ * Where an adapter reads each claim the SQL modules and the provider's hook
+ * write.
+ */
+interface ClaimPaths {
+  /**
+   * The active tenant: the top-level claim, then the same key in
+   * `app_metadata`.
+   */
+  readonly tenant: readonly [string, string];
+  /** `{ [tenantId]: string[] }` of plan features. */
+  readonly features: string;
+  /**
+   * The caller's memberships, a list of `{ scope, id, roles }` or a map of
+   * tenant id to role.
+   */
+  readonly memberships: string;
+  /** The `scope` of tenant entries in the memberships list. */
+  readonly scope: string;
+}
+/**
+ * The claim paths for `config.claims`, with defaults. For a generated schema,
+ * pass `claimsOf(meta)`.
+ */
+declare function claimPaths(claims?: Partial<ClaimsMeta>): ClaimPaths;
+/**
+ * Where the active tenant is read from: the top-level claim, then
+ * `app_metadata`.
+ */
+declare function tenantClaimPaths(tenant?: string): readonly [string, string];
+//#endregion
+//#region src/generators/extras.d.ts
+/** A schema for a function's arguments or one of a block's inputs. */
+interface ExtraSchema {
+  /** Export name: `listTasksArgs`, `taskInput`. */
+  readonly name: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly fields: Readonly<Record<string, FieldSpec>>;
+}
+/** What a function returns, when it is a table row or a scalar. */
+interface ResultSchema {
+  /** Export name: `listTasksResult`. */
+  readonly name: string;
+  readonly title: string;
+  /** The function returns a set: the schema is an array. */
+  readonly set: boolean;
+  /** A single result may be `null`; for sets, each scalar item may be. */
+  readonly nullable: boolean;
+  readonly of: {
+    readonly kind: "row";
+    readonly table: string;
+  } | {
+    readonly kind: "scalar";
+    readonly scalar: ScalarKind;
+  };
+}
+interface ExtraSchemas {
+  readonly inputs: readonly ExtraSchema[];
+  readonly results: readonly ResultSchema[];
+}
+//#endregion
+//#region src/generators/json-schema-target.d.ts
+/** The JSON Schema dialects the generators and MCP emit. */
+type JsonSchemaTarget = "draft-2020-12" | "draft-07" | "openapi-3.0";
+//#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>>;
+  };
+  readonly runtimeImport?: string;
+}
+interface CommentEntry {
+  readonly id: number;
+  readonly schema: string;
+  readonly name: string;
+  readonly comment: string | null;
+}
+/**
+ * The catalog parts docs read: `GeneratorInput` satisfies it. Runtime callers
+ * that only have `meta` (OpenAPI, MCP) pass none and get no docs.
+ */
+interface DocsSource extends SchemaSource {
+  readonly introspection?: {
+    readonly tables: readonly CommentEntry[];
+    readonly views: readonly CommentEntry[];
+    readonly materializedViews?: readonly CommentEntry[];
+    readonly columns: readonly {
+      readonly table_id: number;
+      readonly name: string;
+      readonly comment: string | null;
+      readonly check: string | null;
+    }[];
+  };
+  readonly extras?: {
+    readonly tables: readonly {
+      readonly schema: string;
+      readonly name: string;
+      readonly checks: readonly {
+        readonly definition: string;
+      }[];
+    }[];
+  };
+}
+//#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;
+  /**
+   * The dialect. `draft-2020-12` (the default) writes `$defs`; `draft-07` and
+   * `openapi-3.0` (`nullable`, `example`) write `definitions`.
+   */
+  readonly target?: JsonSchemaTarget;
+  /**
+   * Give each writable field a `title` label (from a short column comment or
+   * its name), for form builders that read JSON Schema.
+   */
+  readonly fieldMeta?: boolean;
+}
+type JsonSchema = Record<string, unknown>;
+/**
+ * JSON Schema `$defs` for every table: `customersRow`, `customersInsert`, ...
+ * `target` lowers the document to draft-07 or the OpenAPI 3.0 dialect, which
+ * keep the schemas under `definitions`.
+ */
+declare function buildJsonSchema(input: DocsSource, id?: string, target?: JsonSchemaTarget, extras?: ExtraSchemas): JsonSchema;
+/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
+declare function jsonSchema(options?: JsonSchemaGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/factories.d.ts
+interface FactoriesGeneratorOptions {
+  /**
+   * Output path relative to the project root. Defaults to
+   * `<output>.factories.ts`.
+   */
+  readonly output?: string;
+  /**
+   * The table keys to write factories for. Defaults to every table, block
+   * tables included under their final names.
+   */
+  readonly tables?: readonly string[];
+  /**
+   * Where the file imports the factory runtime from. Defaults to
+   * `better-supabase/testing` (under `runtimeImport`).
+   */
+  readonly testingImport?: string;
+}
+/**
+ * Test factories, one per table: `factories.customers({ name })` returns an
+ * insert row with valid defaults for the required columns. Defaults respect
+ * enums, check-constraint bounds and `StoragePath` buckets. A foreign key takes
+ * the parent row or its id, and a column without a safe default is a required
+ * input. Block entities also get a factory under their singular noun
+ * (`factories.task`). The file imports `better-supabase/testing`.
+ */
+declare function factories(options?: FactoriesGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/nuqs.d.ts
+interface NuqsGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.nuqs.ts`. */
+  readonly output?: string;
+  /**
+   * The table keys to write search params for (`tasks`, `customerTags`).
+   * Defaults to every table, block tables included under their final names.
+   */
+  readonly tables?: readonly string[];
+  /** The page size `limit` defaults to. Defaults to 25. */
+  readonly limit?: number;
+}
+/**
+ * Search-param parsers for nuqs, one set per table list: a filter for every
+ * column with a closed set of values, `orderBy` over the sortable columns,
+ * `direction`, `cursor` and `limit`, with a cache, a loader and a serializer.
+ * The file imports `nuqs/server`, which the app installs.
+ */
+declare function nuqs(options?: NuqsGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/standard-schema.d.ts
+interface StandardSchemaGeneratorOptions {
+  /**
+   * Output path relative to the project root. Defaults to
+   * `<output>.standard.ts`.
+   */
+  readonly output?: string;
+  /**
+   * Standard Schemas for typed jsonb columns: `{ 'customers.metadata':
+   * './schemas.ts#metadata' }`.
+   */
+  readonly json?: Readonly<Record<string, string>>;
+  /**
+   * Also export `fieldMeta`: a label, a required flag, enum options and bounds
+   * for each writable field, for building forms.
+   */
+  readonly fieldMeta?: boolean;
+}
+/**
+ * Standard Schemas for every table's Row, Insert and Update shape, with no
+ * validation library. Each one also converts to JSON Schema (Standard JSON
+ * Schema), and `validators` plugs into the validation plugin.
+ */
+declare function standardSchema(options?: StandardSchemaGeneratorOptions): 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>>;
+  /**
+   * Also export `fieldMeta`: a label, a required flag, enum options and bounds
+   * for each writable field, for building forms.
+   */
+  readonly fieldMeta?: boolean;
+}
+/** 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>>;
+  /**
+   * `classic` (the default) imports `zod` and chains methods; `mini` imports
+   * `zod/mini` and uses its functional API (`z.nullable(...)`, `.check(...)`),
+   * which tree-shakes to a smaller bundle. Both need zod 4.
+   */
+  readonly flavor?: ZodFlavor;
+  /**
+   * Also export `fieldMeta`: a label, a required flag, enum options and bounds
+   * for each writable field, for building forms.
+   */
+  readonly fieldMeta?: boolean;
+}
+type ZodFlavor = "classic" | "mini";
+/**
+ * Zod 4 schemas for every table's Row, Insert and Update shape, for `zod` or,
+ * with `flavor: 'mini'`, `zod/mini`.
+ */
+declare function zod(options?: ZodGeneratorOptions): Generator;
+//#endregion
+export { ConfigReferences as A, blockSubjectTypes as C, AppTableNames as D, resolveConfig as E, TypedReference as M, resolveJsonSchema as N, BlockTableReference as O, CONFIG_DEFAULTS as P, blockEntityRenames as S, defineConfig as T, DEFAULT_CLAIMS as _, valibot as a, BlockEntity as b, NuqsGeneratorOptions as c, factories as d, JsonSchemaGeneratorOptions as f, ClaimPaths as g, JsonSchemaTarget as h, ValibotGeneratorOptions as i, RoleNames as j, BucketName as k, nuqs as l, jsonSchema as m, ZodGeneratorOptions as n, StandardSchemaGeneratorOptions as o, buildJsonSchema as p, zod as r, standardSchema as s, ZodFlavor as t, FactoriesGeneratorOptions as u, claimPaths as v, CONFIG_SCHEMA_URL as w, blockEntities as x, tenantClaimPaths as y };