@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/core/objects/materialized-view/materialized-view.model.js

@@ -2,6 +2,8 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel, columnPropsSchema, } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
+import { normalizeSecurityLabels, securityLabelPropsSchema, } from "../security-label.types.js";
 import { ReplicaIdentitySchema } from "../table/table.model.js";
 const materializedViewPropsSchema = z.object({
     schema: z.string(),
@@ -22,6 +24,15 @@ const materializedViewPropsSchema = z.object({
     comment: z.string().nullable(),
     columns: z.array(columnPropsSchema),
     privileges: z.array(privilegePropsSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+});
+// pg_get_viewdef(oid) can return NULL when the underlying matview (or its
+// pg_rewrite row) is dropped between catalog scan and resolution, or under
+// transient catalog state during recovery. An unreadable matview cannot be
+// diffed, so we accept NULL here and filter the row out at extraction time
+// rather than crashing the whole catalog parse with a ZodError.
+const materializedViewRowSchema = materializedViewPropsSchema.extend({
+    definition: z.string().nullable(),
 });
 export class MaterializedView extends BasePgModel {
     schema;
@@ -42,6 +53,7 @@ export class MaterializedView extends BasePgModel {
     comment;
     columns;
     privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -64,6 +76,7 @@ export class MaterializedView extends BasePgModel {
         this.comment = props.comment;
         this.columns = props.columns;
         this.privileges = props.privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         return `materializedView:${this.schema}.${this.name}`;
@@ -92,6 +105,7 @@ export class MaterializedView extends BasePgModel {
             comment: this.comment,
             columns: this.columns,
             privileges: this.privileges,
+            security_labels: this.security_labels,
         };
     }
     stableSnapshot() {
@@ -110,12 +124,18 @@ export class MaterializedView extends BasePgModel {
             data: {
                 ...this.dataFields,
                 columns: normalizeColumns(),
+                security_labels: normalizeSecurityLabels(this.security_labels),
             },
         };
     }
 }
-export async function extractMaterializedViews(pool) {
-    const { rows: mvRows } = await pool.query(sql `
+export async function extractMaterializedViews(pool, options) {
+    const mvRows = await extractWithDefinitionRetry({
+        label: "materialized views",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -193,7 +213,7 @@ select
           filter (where src.attname is not null) as cols
       from (
         -- one row for object ACL + one row per column ACL
-        select null::name as attname, c.relacl as acl
+        select null::name as attname, COALESCE(c.relacl, acldefault('r', c.relowner)) as acl
         union all
         select a2.attname, a2.attacl
         from pg_attribute a2
@@ -205,7 +225,20 @@ select
       join lateral aclexplode(src.acl) as x(grantor, grantee, privilege_type, is_grantable) on true
       group by x.grantee, x.privilege_type
     ) as grp
-  ), '[]') as privileges
+  ), '[]') as privileges,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object('provider', sl.provider, 'label', sl.label)
+        order by sl.provider
+      )
+      from pg_catalog.pg_seclabel sl
+      where sl.objoid = c.oid
+        and sl.classoid = 'pg_class'::regclass
+        and sl.objsubid = 0
+    ),
+    '[]'::json
+  ) as security_labels
 from
   pg_catalog.pg_class c
   left outer join extension_oids e on c.oid = e.objid
@@ -220,7 +253,9 @@ group by
 order by
   c.relnamespace::regnamespace, c.relname
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = mvRows.map((row) => materializedViewPropsSchema.parse(row));
+            return result.rows.map((row) => materializedViewRowSchema.parse(row));
+        },
+    });
+    const validatedRows = mvRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new MaterializedView(row));
 }

package/dist/core/objects/procedure/changes/procedure.alter.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Procedure } from "../procedure.model.ts";
 import { AlterProcedureChange } from "./procedure.base.ts";
 /**
@@ -37,7 +38,7 @@ export declare class AlterProcedureChangeOwner extends AlterProcedureChange {
         owner: string;
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER FUNCTION/PROCEDURE ... SECURITY { INVOKER | DEFINER }
@@ -51,7 +52,7 @@ export declare class AlterProcedureSetSecurity extends AlterProcedureChange {
         securityDefiner: boolean;
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER FUNCTION/PROCEDURE ... SET/RESET configuration_parameter
@@ -79,7 +80,7 @@ export declare class AlterProcedureSetConfig extends AlterProcedureChange {
         action: "reset_all";
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER FUNCTION/PROCEDURE ... { IMMUTABLE | STABLE | VOLATILE }
@@ -93,7 +94,7 @@ export declare class AlterProcedureSetVolatility extends AlterProcedureChange {
         volatility: string;
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER FUNCTION/PROCEDURE ... { STRICT | CALLED ON NULL INPUT }
@@ -107,7 +108,7 @@ export declare class AlterProcedureSetStrictness extends AlterProcedureChange {
         isStrict: boolean;
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER FUNCTION/PROCEDURE ... { LEAKPROOF | NOT LEAKPROOF }
@@ -121,7 +122,7 @@ export declare class AlterProcedureSetLeakproof extends AlterProcedureChange {
         leakproof: boolean;
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER FUNCTION/PROCEDURE ... PARALLEL { UNSAFE | RESTRICTED | SAFE }
@@ -135,7 +136,7 @@ export declare class AlterProcedureSetParallel extends AlterProcedureChange {
         parallelSafety: string;
     });
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Replace a procedure by dropping and recreating it.

package/dist/core/objects/procedure/changes/procedure.alter.js

@@ -1,5 +1,10 @@
 import { formatConfigValue } from "../utils.js";
 import { AlterProcedureChange } from "./procedure.base.js";
+/** Build schema.name(args) for ALTER statements so overloaded functions are unambiguous. */
+function procedureSignature(procedure) {
+    const args = procedure.argument_types?.join(", ") ?? "";
+    return `${procedure.schema}.${procedure.name}(${args})`;
+}
 /**
  * ALTER FUNCTION/PROCEDURE ... OWNER TO ...
  */
@@ -15,12 +20,12 @@ export class AlterProcedureChangeOwner extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             "OWNER TO",
             this.owner,
         ].join(" ");
@@ -41,7 +46,7 @@ export class AlterProcedureSetSecurity extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const security = this.securityDefiner
             ? "SECURITY DEFINER"
@@ -49,7 +54,7 @@ export class AlterProcedureSetSecurity extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             security,
         ].join(" ");
     }
@@ -74,11 +79,11 @@ export class AlterProcedureSetConfig extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const head = [
             "ALTER",
             this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
         ].join(" ");
         if (this.action === "reset_all")
             return `${head} RESET ALL`;
@@ -103,7 +108,7 @@ export class AlterProcedureSetVolatility extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const volMap = {
             i: "IMMUTABLE",
@@ -113,7 +118,7 @@ export class AlterProcedureSetVolatility extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             volMap[this.volatility],
         ].join(" ");
     }
@@ -133,13 +138,13 @@ export class AlterProcedureSetStrictness extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const strictness = this.isStrict ? "STRICT" : "CALLED ON NULL INPUT";
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             strictness,
         ].join(" ");
     }
@@ -159,15 +164,10 @@ export class AlterProcedureSetLeakproof extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const leak = this.leakproof ? "LEAKPROOF" : "NOT LEAKPROOF";
-        return [
-            "ALTER",
-            objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
-            leak,
-        ].join(" ");
+        return ["ALTER", objectType, procedureSignature(this.procedure), leak].join(" ");
     }
 }
 /**
@@ -185,7 +185,7 @@ export class AlterProcedureSetParallel extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const parallelMap = {
             u: "PARALLEL UNSAFE",
@@ -195,7 +195,7 @@ export class AlterProcedureSetParallel extends AlterProcedureChange {
         return [
             "ALTER",
             objectType,
-            `${this.procedure.schema}.${this.procedure.name}`,
+            procedureSignature(this.procedure),
             parallelMap[this.parallelSafety],
         ].join(" ");
     }

package/dist/core/objects/procedure/changes/procedure.base.d.ts

@@ -2,7 +2,7 @@ import { BaseChange } from "../../base.change.ts";
 import type { Procedure } from "../procedure.model.ts";
 declare abstract class BaseProcedureChange extends BaseChange {
     abstract readonly procedure: Procedure;
-    abstract readonly scope: "object" | "comment" | "privilege";
+    abstract readonly scope: "object" | "comment" | "privilege" | "security_label";
     readonly objectType: "procedure";
 }
 export declare abstract class CreateProcedureChange extends BaseProcedureChange {

package/dist/core/objects/procedure/changes/procedure.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Procedure } from "../procedure.model.ts";
 import { CreateProcedureChange, DropProcedureChange } from "./procedure.base.ts";
 export type CommentProcedure = CreateCommentOnProcedure | DropCommentOnProcedure;
@@ -12,7 +13,7 @@ export declare class CreateCommentOnProcedure extends CreateProcedureChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnProcedure extends DropProcedureChange {
     readonly procedure: Procedure;
@@ -22,5 +23,5 @@ export declare class DropCommentOnProcedure extends DropProcedureChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `procedure:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/procedure/changes/procedure.comment.js

@@ -17,7 +17,7 @@ export class CreateCommentOnProcedure extends CreateProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON",
             this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",
@@ -41,7 +41,7 @@ export class DropCommentOnProcedure extends DropProcedureChange {
     get requires() {
         return [stableId.comment(this.procedure.stableId), this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON",
             this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION",

package/dist/core/objects/procedure/changes/procedure.create.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Procedure } from "../procedure.model.ts";
 import { CreateProcedureChange } from "./procedure.base.ts";
 /**
@@ -38,5 +39,5 @@ export declare class CreateProcedure extends CreateProcedureChange {
     });
     get creates(): `procedure:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/procedure/changes/procedure.create.js

@@ -66,7 +66,7 @@ export class CreateProcedure extends CreateProcedureChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         // Use the server-generated CREATE statement for functions/procedures
         // Normalize trailing semicolon and OR REPLACE clause according to flag
         let definition = this.procedure.definition.trim();

package/dist/core/objects/procedure/changes/procedure.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Procedure } from "../procedure.model.ts";
 import { DropProcedureChange } from "./procedure.base.ts";
 /**
@@ -19,5 +20,5 @@ export declare class DropProcedure extends DropProcedureChange {
     });
     get drops(): `procedure:${string}`[];
     get requires(): `procedure:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/procedure/changes/procedure.drop.js

@@ -24,7 +24,7 @@ export class DropProcedure extends DropProcedureChange {
     get requires() {
         return [this.procedure.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         // Build argument list
         const args = formatFunctionArguments(this.procedure.argument_names, this.procedure.argument_types, this.procedure.argument_modes);

package/dist/core/objects/procedure/changes/procedure.privilege.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Procedure } from "../procedure.model.ts";
 import { AlterProcedureChange } from "./procedure.base.ts";
 export type ProcedurePrivilege = GrantProcedurePrivileges | RevokeProcedurePrivileges | RevokeGrantOptionProcedurePrivileges;
@@ -35,7 +36,7 @@ export declare class GrantProcedurePrivileges extends AlterProcedureChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `procedure:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a procedure.
@@ -72,7 +73,7 @@ export declare class RevokeProcedurePrivileges extends AlterProcedureChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `procedure:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a procedure.
@@ -94,5 +95,5 @@ export declare class RevokeGrantOptionProcedurePrivileges extends AlterProcedure
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `procedure:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/procedure/changes/procedure.privilege.js

@@ -34,7 +34,7 @@ export class GrantProcedurePrivileges extends AlterProcedureChange {
     get requires() {
         return [this.procedure.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const hasGrantable = this.privileges.some((p) => p.grantable);
         const hasBase = this.privileges.some((p) => !p.grantable);
         if (hasGrantable && hasBase) {
@@ -92,7 +92,7 @@ export class RevokeProcedurePrivileges extends AlterProcedureChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const kindPrefix = getObjectKindPrefix(objectKind);
         const list = this.privileges.map((p) => p.privilege);
@@ -131,7 +131,7 @@ export class RevokeGrantOptionProcedurePrivileges extends AlterProcedureChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
         const kindPrefix = getObjectKindPrefix(objectKind);
         const privSql = formatObjectPrivilegeList(objectKind, this.privilegeNames, this.version);

package/dist/core/objects/procedure/changes/procedure.security-label.d.ts

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { Procedure } from "../procedure.model.ts";
+import { CreateProcedureChange, DropProcedureChange } from "./procedure.base.ts";
+export type SecurityLabelProcedure = CreateSecurityLabelOnProcedure | DropSecurityLabelOnProcedure;
+export declare class CreateSecurityLabelOnProcedure extends CreateProcedureChange {
+    readonly procedure: Procedure;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        procedure: Procedure;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnProcedure extends DropProcedureChange {
+    readonly procedure: Procedure;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        procedure: Procedure;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `procedure:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/procedure/changes/procedure.security-label.js

@@ -0,0 +1,69 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateProcedureChange, DropProcedureChange, } from "./procedure.base.js";
+function targetKeyword(p) {
+    return p.kind === "p" ? "PROCEDURE" : "FUNCTION";
+}
+function procedureIdentity(p) {
+    return `${p.schema}.${p.name}(${(p.argument_types ?? []).join(",")})`;
+}
+export class CreateSecurityLabelOnProcedure extends CreateProcedureChange {
+    procedure;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.procedure.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON",
+            targetKeyword(this.procedure),
+            procedureIdentity(this.procedure),
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnProcedure extends DropProcedureChange {
+    procedure;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.procedure.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.procedure.stableId, this.securityLabel.provider),
+            this.procedure.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON",
+            targetKeyword(this.procedure),
+            procedureIdentity(this.procedure),
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/procedure/changes/procedure.types.d.ts

@@ -3,4 +3,6 @@ import type { CommentProcedure } from "./procedure.comment.ts";
 import type { CreateProcedure } from "./procedure.create.ts";
 import type { DropProcedure } from "./procedure.drop.ts";
 import type { ProcedurePrivilege } from "./procedure.privilege.ts";
-export type ProcedureChange = AlterProcedure | CommentProcedure | CreateProcedure | DropProcedure | ProcedurePrivilege;
+import type { SecurityLabelProcedure } from "./procedure.security-label.ts";
+/** Union of all procedure-related change variants (`objectType: "procedure"`). @category Change Types */
+export type ProcedureChange = AlterProcedure | CommentProcedure | CreateProcedure | DropProcedure | ProcedurePrivilege | SecurityLabelProcedure;

package/dist/core/objects/procedure/procedure.diff.d.ts

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { ProcedureChange } from "./changes/procedure.types.ts";
 import type { Procedure } from "./procedure.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Procedure } from "./procedure.model.ts";
  * @param branch - The procedures in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffProcedures(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Procedure>, branch: Record<string, Procedure>): ProcedureChange[];
+export declare function diffProcedures(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Procedure>, branch: Record<string, Procedure>): ProcedureChange[];