@supabase/postgrest-typegen 0.4.0 → 0.6.0

package/dist/introspection/sql/view_definitions.sql.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaFilterProps } from "./common.ts";
+/**
+ * The query tree of every view and materialized view in the filtered schemas,
+ * plus every view they read from in any schema, with the `NOT NULL` columns
+ * each one references. `inferNonNullViewColumns` resolves view column
+ * nullability from it.
+ */
+export declare const VIEW_DEFINITIONS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/view_definitions.sql.js

@@ -0,0 +1,43 @@
+/**
+ * The query tree of every view and materialized view in the filtered schemas,
+ * plus every view they read from in any schema, with the `NOT NULL` columns
+ * each one references. `inferNonNullViewColumns` resolves view column
+ * nullability from it.
+ */
+export const VIEW_DEFINITIONS_SQL = (props) => /* SQL */ `
+WITH RECURSIVE view_closure(oid) AS (
+  SELECT c.oid
+  FROM pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE
+    ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+    c.relkind IN ('v', 'm')
+  UNION
+  SELECT dep.refobjid
+  FROM view_closure vc
+  JOIN pg_rewrite r ON r.ev_class = vc.oid AND r.rulename = '_RETURN'
+  JOIN pg_depend dep ON dep.classid = 'pg_rewrite' :: regclass
+    AND dep.objid = r.oid
+    AND dep.refclassid = 'pg_class' :: regclass
+  JOIN pg_class rc ON rc.oid = dep.refobjid AND rc.relkind IN ('v', 'm')
+)
+SELECT
+  r.ev_class :: int8 AS view_id,
+  r.ev_action :: text AS definition,
+  COALESCE(
+    (
+      SELECT json_agg(json_build_array(dep.refobjid :: int8, dep.refobjsubid))
+      FROM pg_depend dep
+      JOIN pg_attribute a ON a.attrelid = dep.refobjid AND a.attnum = dep.refobjsubid
+      JOIN pg_type t ON t.oid = a.atttypid
+      WHERE dep.classid = 'pg_rewrite' :: regclass
+        AND dep.objid = r.oid
+        AND dep.refclassid = 'pg_class' :: regclass
+        AND dep.refobjsubid > 0
+        AND (a.attnotnull OR t.typtype = 'd' AND t.typnotnull)
+    ),
+    '[]'
+  ) AS non_null_columns
+FROM view_closure vc
+JOIN pg_rewrite r ON r.ev_class = vc.oid AND r.rulename = '_RETURN'
+`;

package/dist/introspection/view-nullability.d.ts

@@ -0,0 +1,14 @@
+import type { PostgresColumn } from "../types.ts";
+/** A row of `VIEW_DEFINITIONS_SQL`. */
+export interface ViewDefinitionRow {
+    view_id: number | string;
+    definition: string;
+    non_null_columns: [number | string, number | string][];
+}
+/**
+ * Mark view and materialized view columns as not nullable when PostgreSQL can
+ * prove it from the view's query tree (see {@link inferNonNullViewColumns}) or
+ * when the column comment has an `@notNull` line. PostgreSQL never sets
+ * `attnotnull` on view columns, so without this every one of them is nullable.
+ */
+export declare function applyViewColumnNullability<T extends PostgresColumn>(columns: T[], rows: ViewDefinitionRow[]): T[];

package/dist/introspection/view-nullability.js

@@ -0,0 +1,167 @@
+import { isNode, parseNodeTree, } from "./node-tree.js";
+const RTE_RELATION = "0";
+const RTE_SUBQUERY = "1";
+const RTE_JOIN = "2";
+const RTE_CTE = "6";
+const RTE_GROUP = "9";
+const JOIN_INNER = "0";
+const JOIN_LEFT = "1";
+const JOIN_RIGHT = "3";
+const NOT_NULL_DIRECTIVE = /^\s*@notNull\s*$/m;
+/**
+ * Mark view and materialized view columns as not nullable when PostgreSQL can
+ * prove it from the view's query tree (see {@link inferNonNullViewColumns}) or
+ * when the column comment has an `@notNull` line. PostgreSQL never sets
+ * `attnotnull` on view columns, so without this every one of them is nullable.
+ */
+export function applyViewColumnNullability(columns, rows) {
+    const viewIds = new Set(rows.map((row) => String(row.view_id)));
+    const nonNull = inferNonNullViewColumns(rows);
+    return columns.map((column) => column.is_nullable &&
+        viewIds.has(String(column.table_id)) &&
+        (nonNull.has(column.id) || NOT_NULL_DIRECTIVE.test(column.comment ?? ""))
+        ? { ...column, is_nullable: false }
+        : column);
+}
+/**
+ * The ids (`<view oid>.<attnum>`) of the view columns that can never be null.
+ * A column qualifies when it is a plain reference to a `NOT NULL` column, or
+ * to a view column that qualifies, followed through joins, subqueries,
+ * non-recursive CTEs and `GROUP BY`, and nothing on the way puts it on the
+ * nullable side of an outer join, in a set operation or under grouping sets.
+ * The outer-join check walks the join tree instead of reading
+ * `varnullingrels`, which PostgreSQL 15 does not have.
+ */
+function inferNonNullViewColumns(rows) {
+    const definitions = new Map(rows.map((row) => [String(row.view_id), row.definition]));
+    const nonNullBaseColumns = new Set(rows.flatMap((row) => row.non_null_columns.map(([relation, attnum]) => `${relation}.${attnum}`)));
+    const resolved = new Map();
+    const nullableIndexesByQuery = new Map();
+    const nullableIndexesOf = (query) => {
+        let indexes = nullableIndexesByQuery.get(query);
+        if (indexes === undefined) {
+            indexes = nullableRangeTableIndexes(query);
+            nullableIndexesByQuery.set(query, indexes);
+        }
+        return indexes;
+    };
+    const nonNullColumnsOfView = (viewId) => {
+        const cached = resolved.get(viewId);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const columns = new Set();
+        resolved.set(viewId, columns);
+        try {
+            const tree = parseNodeTree(definitions.get(viewId) ?? "");
+            const query = Array.isArray(tree) ? tree[0] : tree;
+            if (isNode(query, "QUERY") && allowsNonNull(query)) {
+                for (const entry of list(query.fields.targetList)) {
+                    if (isNode(entry, "TARGETENTRY") &&
+                        entry.fields.resjunk !== "true" &&
+                        isNonNullExpression(entry.fields.expr, [query])) {
+                        columns.add(Number(entry.fields.resno));
+                    }
+                }
+            }
+        }
+        catch {
+            columns.clear();
+        }
+        return columns;
+    };
+    const isNonNullColumn = (relation, attnum) => definitions.has(relation)
+        ? nonNullColumnsOfView(relation).has(attnum)
+        : nonNullBaseColumns.has(`${relation}.${attnum}`);
+    const isNonNullExpression = (expression, queries) => {
+        const query = queries.at(-1);
+        if (query === undefined ||
+            !isNode(expression, "VAR") ||
+            expression.fields.varlevelsup !== "0") {
+            return false;
+        }
+        const varno = Number(expression.fields.varno);
+        const attnum = Number(expression.fields.varattno);
+        if (attnum <= 0 || nullableIndexesOf(query).has(varno)) {
+            return false;
+        }
+        const entry = list(query.fields.rtable)[varno - 1];
+        if (!isNode(entry, "RANGETBLENTRY")) {
+            return false;
+        }
+        switch (entry.fields.rtekind) {
+            case RTE_RELATION:
+                return (typeof entry.fields.relid === "string" &&
+                    isNonNullColumn(entry.fields.relid, attnum));
+            case RTE_SUBQUERY:
+                return isNonNullOutput(entry.fields.subquery, attnum, queries);
+            case RTE_JOIN:
+                return isNonNullExpression(list(entry.fields.joinaliasvars)[attnum - 1], queries);
+            case RTE_GROUP:
+                return isNonNullExpression(list(entry.fields.groupexprs)[attnum - 1], queries);
+            case RTE_CTE: {
+                const levelsUp = Number(entry.fields.ctelevelsup);
+                const owner = queries.at(-1 - levelsUp);
+                const cte = list(owner?.fields.cteList).find((candidate) => isNode(candidate, "COMMONTABLEEXPR") &&
+                    candidate.fields.ctename === entry.fields.ctename);
+                return (isNode(cte) &&
+                    cte.fields.cterecursive !== "true" &&
+                    isNonNullOutput(cte.fields.ctequery, attnum, queries.slice(0, queries.length - levelsUp)));
+            }
+            default:
+                return false;
+        }
+    };
+    const isNonNullOutput = (subquery, resno, queries) => {
+        if (!isNode(subquery, "QUERY") || !allowsNonNull(subquery)) {
+            return false;
+        }
+        const entry = list(subquery.fields.targetList).find((candidate) => isNode(candidate, "TARGETENTRY") &&
+            Number(candidate.fields.resno) === resno);
+        return (isNode(entry) &&
+            isNonNullExpression(entry.fields.expr, [...queries, subquery]));
+    };
+    const result = new Set();
+    for (const viewId of definitions.keys()) {
+        for (const attnum of nonNullColumnsOfView(viewId)) {
+            result.add(`${viewId}.${attnum}`);
+        }
+    }
+    return result;
+}
+function allowsNonNull(query) {
+    return (query.fields.setOperations === null &&
+        list(query.fields.groupingSets).length === 0);
+}
+/**
+ * The range table indexes that sit on the nullable side of an outer join in
+ * the query's join tree, including the indexes of nested joins themselves.
+ */
+function nullableRangeTableIndexes(query) {
+    const nullable = new Set();
+    const visit = (node, isNullable) => {
+        if (isNode(node, "RANGETBLREF")) {
+            if (isNullable) {
+                nullable.add(Number(node.fields.rtindex));
+            }
+        }
+        else if (isNode(node, "FROMEXPR")) {
+            for (const item of list(node.fields.fromlist)) {
+                visit(item, isNullable);
+            }
+        }
+        else if (isNode(node, "JOINEXPR")) {
+            const joinType = node.fields.jointype;
+            if (isNullable) {
+                nullable.add(Number(node.fields.rtindex));
+            }
+            visit(node.fields.larg, isNullable || (joinType !== JOIN_INNER && joinType !== JOIN_LEFT));
+            visit(node.fields.rarg, isNullable || (joinType !== JOIN_INNER && joinType !== JOIN_RIGHT));
+        }
+    };
+    visit(query.fields.jointree, false);
+    return nullable;
+}
+function list(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/rpc.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorMetadata, RpcFunction } from "./types.ts";
+export declare function resolveRpcFunctions(metadata: GeneratorMetadata): RpcFunction[];

package/dist/rpc.js

@@ -0,0 +1,232 @@
+/**
+ * Resolves the PostgREST view of `GeneratorMetadata.functions`.
+ *
+ * The raw `functions` collection is `pg_proc` as introspected. Which of those
+ * functions PostgREST exposes under `/rpc`, how their overloads group, what a
+ * call returns and whether a function doubles as a computed field or an
+ * embeddable relation are PostgREST rules, not language rules. This pass
+ * applies them once so every generator, in this package or in another SDK
+ * repo reading the serialized document, emits the same RPC surface.
+ *
+ * Pure and deterministic: the output is canonically ordered regardless of the
+ * order of the input collections. `introspect()` attaches the result as
+ * `rpcFunctions`; generators that meet a document without it (produced by a
+ * version predating the collection, or by a custom producer) run this pass
+ * themselves.
+ */
+import { compareStrings } from "./collation.js";
+/** json, jsonb and text: the types PostgREST accepts for a single unnamed parameter. */
+const UNNAMED_ARG_TYPE_IDS = new Set([114, 3802, 25]);
+const INPUT_ARG_MODES = new Set(["in", "inout", "variadic"]);
+/** A NUL separator cannot occur in an identifier, so names with dots never collide. */
+const qualifiedKey = (schema, name) => `${schema}\0${name}`;
+export function resolveRpcFunctions(metadata) {
+    const schemaNames = new Set(metadata.schemas.map(({ name }) => name));
+    const typesById = new Map(metadata.types.map((type) => [type.id, type]));
+    const relationTypesById = new Map(metadata.types
+        .filter((type) => type.type_relation_id !== null)
+        .map((type) => [type.id, type]));
+    const relations = [
+        ...metadata.tables,
+        ...metadata.foreignTables,
+        ...metadata.views,
+        ...metadata.materializedViews,
+    ];
+    const relationsById = new Map(relations.map((relation) => [relation.id, relation]));
+    const relationsBySchemaName = new Map(relations.map((relation) => [
+        qualifiedKey(relation.schema, relation.name),
+        relation,
+    ]));
+    const columnNamesByRelationId = new Map();
+    for (const column of metadata.columns) {
+        let names = columnNamesByRelationId.get(column.table_id);
+        if (!names) {
+            names = new Set();
+            columnNamesByRelationId.set(column.table_id, names);
+        }
+        names.add(column.name);
+    }
+    const typeReference = (typeId) => {
+        const type = typesById.get(typeId);
+        return {
+            type_id: typeId,
+            format: type?.name ?? null,
+            type_schema: type?.schema ?? null,
+        };
+    };
+    const typeName = (typeId) => typesById.get(typeId)?.name ?? "unknown";
+    // The relation a return type stands for, or a composite type's name when the
+    // return type is one, since both are relations in `pg_class`. Resolved
+    // against every schema: a function may return rows of another schema.
+    const returnRelationName = (fn) => {
+        if (fn.return_type_relation_id === null)
+            return null;
+        return (relationsById.get(fn.return_type_relation_id)?.name ??
+            relationTypesById.get(fn.return_type_id)?.name ??
+            null);
+    };
+    // The function is a computed field of the relation whose row type its sole
+    // input parameter has, provided the relation lives in the function's schema
+    // and has no column of the function's name: PostgREST resolves the name to
+    // the column, so such a function is neither selectable nor part of `Row`.
+    // When the parameter's type is not in `types` (a reduced custom document),
+    // the rendered argument list may still name the relation.
+    const computedFieldOf = ({ fn, inArgs }) => {
+        const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
+        if (!soleInArg)
+            return null;
+        const argType = relationTypesById.get(soleInArg.type_id);
+        const relation = argType
+            ? relationsById.get(argType.type_relation_id)
+            : typesById.has(soleInArg.type_id)
+                ? undefined
+                : relationsBySchemaName.get(qualifiedKey(fn.schema, fn.argument_types));
+        if (!relation || relation.schema !== fn.schema)
+            return null;
+        if (columnNamesByRelationId.get(relation.id)?.has(fn.name))
+            return null;
+        return relation.id;
+    };
+    const isCallable = ({ inArgs }) => {
+        if (inArgs.length === 0)
+            return true;
+        if (!inArgs.some(({ name }) => name === ""))
+            return true;
+        if (inArgs.every((arg) => arg.name !== "" ||
+            (arg.has_default === true && UNNAMED_ARG_TYPE_IDS.has(arg.type_id)))) {
+            return true;
+        }
+        const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
+        return (soleInArg !== undefined &&
+            soleInArg.name === "" &&
+            (UNNAMED_ARG_TYPE_IDS.has(soleInArg.type_id) ||
+                relationTypesById.has(soleInArg.type_id)));
+    };
+    const overloadError = (candidate, group) => {
+        const { fn, inArgs } = candidate;
+        const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
+        if (group.length > 1) {
+            // A no-argument overload next to one whose sole unnamed parameter has a
+            // default: PostgREST cannot pick one for an empty call.
+            if (inArgs.length === 0) {
+                const conflicting = group.find((other) => other !== candidate &&
+                    other.inArgs.length === 1 &&
+                    other.inArgs[0]?.name === "" &&
+                    other.inArgs[0].has_default === true);
+                if (conflicting) {
+                    return `Could not choose the best candidate function between: ${fn.schema}.${fn.name}(), ${fn.schema}.${fn.name}( => ${typeName(conflicting.fn.return_type_id)}). Try renaming the parameters or the function itself in the database so function overloading can be resolved`;
+                }
+            }
+            // Overloads whose sole parameter shares a name but not a type: a call
+            // carries no type information, so PostgREST cannot pick one.
+            if (soleInArg && soleInArg.name !== "") {
+                const conflicting = group.filter((other) => other !== candidate &&
+                    other.inArgs.length === 1 &&
+                    other.inArgs[0]?.name === soleInArg.name &&
+                    other.inArgs[0].type_id !== soleInArg.type_id);
+                if (conflicting.length > 0) {
+                    const conflictList = [candidate, ...conflicting]
+                        .sort((a, b) => (a.inArgs[0]?.type_id || 0) - (b.inArgs[0]?.type_id || 0))
+                        .map((other) => `${fn.schema}.${fn.name}(${other.inArgs
+                        .map((arg) => `${arg.name} => ${typeName(arg.type_id)}`)
+                        .join(", ")})`)
+                        .join(", ");
+                    return `Could not choose the best candidate function between: ${conflictList}. Try renaming the parameters or the function itself in the database so function overloading can be resolved`;
+                }
+            }
+        }
+        // PostgREST passes a sole unnamed parameter only when it is json, jsonb or
+        // text, so a function taking a row this way is a computed field or a
+        // computed relationship, reachable by embedding it from its relation and
+        // never through `/rpc`, whatever it returns.
+        if (soleInArg &&
+            soleInArg.name === "" &&
+            relationTypesById.has(soleInArg.type_id)) {
+            return `the function ${fn.schema}.${fn.name} with parameter or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache`;
+        }
+        return null;
+    };
+    const resolveOverload = (candidate, group) => {
+        const { fn, inArgs } = candidate;
+        const args = inArgs
+            .map((arg) => {
+            const relationId = relationTypesById.get(arg.type_id)?.type_relation_id;
+            return {
+                name: arg.name,
+                mode: arg.mode,
+                ...typeReference(arg.type_id),
+                has_default: arg.has_default === true,
+                relation_id: relationId !== undefined && relationsById.has(relationId)
+                    ? relationId
+                    : null,
+            };
+        })
+            .sort((a, b) => compareStrings(a.name, b.name));
+        const tableColumns = fn.args
+            .filter(({ mode }) => mode === "table")
+            .map(({ name, type_id }) => ({ name, ...typeReference(type_id) }))
+            .sort((a, b) => compareStrings(a.name, b.name));
+        const relationName = returnRelationName(fn);
+        const returnsMultipleRows = fn.prorows !== null && fn.prorows > 1;
+        // A function whose sole parameter (of any mode) is a row type is embedded
+        // from that relation; any other row-returning function embeds from `*`.
+        const soleArg = fn.args.length === 1 ? fn.args[0] : undefined;
+        const sourceType = soleArg && relationTypesById.get(soleArg.type_id);
+        const setofOptions = relationName === null
+            ? null
+            : {
+                from: sourceType ? sourceType.format : "*",
+                to: relationName,
+                is_one_to_one: sourceType && !fn.is_set_returning_function
+                    ? true
+                    : !returnsMultipleRows,
+                is_setof_return: fn.is_set_returning_function,
+            };
+        return {
+            function_id: fn.id,
+            args,
+            returns: {
+                ...typeReference(fn.return_type_id),
+                relation_id: fn.return_type_relation_id !== null &&
+                    relationsById.has(fn.return_type_relation_id)
+                    ? fn.return_type_relation_id
+                    : null,
+                columns: tableColumns.length > 0 ? tableColumns : null,
+            },
+            is_set_returning: fn.is_set_returning_function,
+            rows_estimate: fn.prorows,
+            setof_options: setofOptions,
+            computed_field_of: computedFieldOf(candidate),
+            error: overloadError(candidate, group),
+        };
+    };
+    const groups = new Map();
+    for (const fn of metadata.functions) {
+        if (!schemaNames.has(fn.schema))
+            continue;
+        const inArgs = fn.args.filter((arg) => INPUT_ARG_MODES.has(arg.mode));
+        const candidate = { fn, inArgs };
+        if (!isCallable(candidate))
+            continue;
+        const key = qualifiedKey(fn.schema, fn.name);
+        let group = groups.get(key);
+        if (!group) {
+            group = [];
+            groups.set(key, group);
+        }
+        group.push(candidate);
+    }
+    return [...groups.values()]
+        .map((group) => {
+        const sorted = [...group].sort((a, b) => compareStrings(a.fn.argument_types, b.fn.argument_types) ||
+            compareStrings(a.fn.return_type, b.fn.return_type) ||
+            a.fn.id - b.fn.id);
+        const [{ fn }] = sorted;
+        return {
+            schema: fn.schema,
+            name: fn.name,
+            overloads: sorted.map((candidate) => resolveOverload(candidate, sorted)),
+        };
+    })
+        .sort((a, b) => compareStrings(a.schema, b.schema) || compareStrings(a.name, b.name));
+}

package/dist/sort.js

@@ -60,5 +60,28 @@ export function sortGeneratorMetadata(metadata) {
             args: [...fn.args].sort((a, b) => compareStrings(a.name, b.name)),
         })),
         types: [...metadata.types].sort(bySchemaName),
+        // `resolveRpcFunctions` orders the overloads of a function by signature,
+        // and that order is kept here, like composite attributes; the entries,
+        // their args and their table columns are addressed by name.
+        ...(metadata.rpcFunctions === undefined
+            ? {}
+            : {
+                rpcFunctions: [...metadata.rpcFunctions]
+                    .sort((a, b) => compareStrings(a.schema, b.schema) ||
+                    compareStrings(a.name, b.name))
+                    .map((fn) => ({
+                    ...fn,
+                    overloads: fn.overloads.map((overload) => ({
+                        ...overload,
+                        args: [...overload.args].sort((a, b) => compareStrings(a.name, b.name)),
+                        returns: {
+                            ...overload.returns,
+                            columns: overload.returns.columns === null
+                                ? null
+                                : [...overload.returns.columns].sort((a, b) => compareStrings(a.name, b.name)),
+                        },
+                    })),
+                })),
+            }),
     };
 }

package/dist/types.d.ts

@@ -208,6 +208,119 @@ declare const postgresViewSchema: import("arktype/internal/variants/object.ts").
     }[] | undefined;
 }, {}>;
 export type PostgresView = typeof postgresViewSchema.infer;
+/**
+ * A reference to a `types` entry by oid. `format` is the type's `name` (the
+ * same spelling `PostgresColumn.format` uses, `_` prefixed for arrays) and
+ * `type_schema` its schema; both are `null` when the type is not in `types`,
+ * which never happens in a document produced by `introspect()`.
+ */
+declare const rpcTypeReferenceSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type_id: number;
+    format: string | null;
+    type_schema: string | null;
+}, {}>;
+export type RpcTypeReference = typeof rpcTypeReferenceSchema.infer;
+declare const rpcFunctionArgSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type_id: number;
+    format: string | null;
+    type_schema: string | null;
+    name: string;
+    mode: "in" | "inout" | "variadic";
+    has_default: boolean;
+    relation_id: number | null;
+}, {}>;
+export type RpcFunctionArg = typeof rpcFunctionArgSchema.infer;
+declare const rpcFunctionReturnsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type_id: number;
+    format: string | null;
+    type_schema: string | null;
+    relation_id: number | null;
+    columns: {
+        type_id: number;
+        format: string | null;
+        type_schema: string | null;
+        name: string;
+    }[] | null;
+}, {}>;
+export type RpcFunctionReturns = typeof rpcFunctionReturnsSchema.infer;
+declare const rpcFunctionOverloadSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    function_id: number;
+    args: {
+        type_id: number;
+        format: string | null;
+        type_schema: string | null;
+        name: string;
+        mode: "in" | "inout" | "variadic";
+        has_default: boolean;
+        relation_id: number | null;
+    }[];
+    returns: {
+        type_id: number;
+        format: string | null;
+        type_schema: string | null;
+        relation_id: number | null;
+        columns: {
+            type_id: number;
+            format: string | null;
+            type_schema: string | null;
+            name: string;
+        }[] | null;
+    };
+    is_set_returning: boolean;
+    rows_estimate: number | null;
+    setof_options: {
+        from: string;
+        to: string;
+        is_one_to_one: boolean;
+        is_setof_return: boolean;
+    } | null;
+    computed_field_of: number | null;
+    error: string | null;
+}, {}>;
+export type RpcFunctionOverload = typeof rpcFunctionOverloadSchema.infer;
+/**
+ * A function PostgREST exposes under `/rpc`, with its overloads resolved.
+ * Produced by `resolveRpcFunctions` from the raw `functions` collection.
+ */
+declare const rpcFunctionSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    schema: string;
+    name: string;
+    overloads: {
+        function_id: number;
+        args: {
+            type_id: number;
+            format: string | null;
+            type_schema: string | null;
+            name: string;
+            mode: "in" | "inout" | "variadic";
+            has_default: boolean;
+            relation_id: number | null;
+        }[];
+        returns: {
+            type_id: number;
+            format: string | null;
+            type_schema: string | null;
+            relation_id: number | null;
+            columns: {
+                type_id: number;
+                format: string | null;
+                type_schema: string | null;
+                name: string;
+            }[] | null;
+        };
+        is_set_returning: boolean;
+        rows_estimate: number | null;
+        setof_options: {
+            from: string;
+            to: string;
+            is_one_to_one: boolean;
+            is_setof_return: boolean;
+        } | null;
+        computed_field_of: number | null;
+        error: string | null;
+    }[];
+}, {}>;
+export type RpcFunction = typeof rpcFunctionSchema.infer;
 /**
  * Bumped whenever `GeneratorMetadata`'s shape changes in a way a consumer
  * should branch on. Out-of-process consumers (a generator in another
@@ -341,6 +454,44 @@ export declare const generatorMetadataSchema: import("arktype/internal/variants/
         comment: string | null;
         type_relation_id: number | null;
     }[];
+    rpcFunctions?: {
+        schema: string;
+        name: string;
+        overloads: {
+            function_id: number;
+            args: {
+                type_id: number;
+                format: string | null;
+                type_schema: string | null;
+                name: string;
+                mode: "in" | "inout" | "variadic";
+                has_default: boolean;
+                relation_id: number | null;
+            }[];
+            returns: {
+                type_id: number;
+                format: string | null;
+                type_schema: string | null;
+                relation_id: number | null;
+                columns: {
+                    type_id: number;
+                    format: string | null;
+                    type_schema: string | null;
+                    name: string;
+                }[] | null;
+            };
+            is_set_returning: boolean;
+            rows_estimate: number | null;
+            setof_options: {
+                from: string;
+                to: string;
+                is_one_to_one: boolean;
+                is_setof_return: boolean;
+            } | null;
+            computed_field_of: number | null;
+            error: string | null;
+        }[];
+    }[] | undefined;
 }, {}>;
 export type GeneratorMetadata = typeof generatorMetadataSchema.infer;
 /**