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

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

@@ -1,4 +1,4 @@
-import { isUserDefinedTypeSchema, stableId } from "../../utils.js";
+import { isUserDefinedTypeSchema, parseTypeString, stableId, } from "../../utils.js";
 import { CreateDomainChange } from "./domain.base.js";
 /**
  * Create a domain.
@@ -26,7 +26,13 @@ export class CreateDomain extends CreateDomainChange {
         this.domain = props.domain;
     }
     get creates() {
-        return [this.domain.stableId];
+        const creates = [this.domain.stableId];
+        for (const constraint of this.domain.constraints) {
+            if (constraint.check_expression && constraint.validated) {
+                creates.push(stableId.constraint(this.domain.schema, this.domain.name, constraint.name));
+            }
+        }
+        return creates;
     }
     get requires() {
         const dependencies = new Set();
@@ -52,13 +58,15 @@ export class CreateDomain extends CreateDomainChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const parts = [];
         // Schema-qualified name
         const domainName = `${this.domain.schema}.${this.domain.name}`;
         // Base type (use formatted string for type+typmod and add schema if needed)
         let baseType = this.domain.base_type_str;
-        if (this.domain.base_type_schema &&
+        const alreadyQualified = parseTypeString(baseType);
+        if (!alreadyQualified &&
+            this.domain.base_type_schema &&
             this.domain.base_type_schema !== "pg_catalog") {
             baseType = `${this.domain.base_type_schema}.${baseType}`;
         }

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

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

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

@@ -22,7 +22,7 @@ export class DropDomain extends DropDomainChange {
     get drops() {
         return [this.domain.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return `DROP DOMAIN ${this.domain.schema}.${this.domain.name}`;
     }
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Domain } from "../domain.model.ts";
 import { AlterDomainChange } from "./domain.base.ts";
 export type DomainPrivilege = GrantDomainPrivileges | RevokeDomainPrivileges | RevokeGrantOptionDomainPrivileges;
@@ -34,7 +35,7 @@ export declare class GrantDomainPrivileges extends AlterDomainChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `domain:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a domain.
@@ -71,7 +72,7 @@ export declare class RevokeDomainPrivileges extends AlterDomainChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `domain:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a domain.
@@ -93,5 +94,5 @@ export declare class RevokeGrantOptionDomainPrivileges extends AlterDomainChange
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `domain:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -33,7 +33,7 @@ export class GrantDomainPrivileges extends AlterDomainChange {
     get requires() {
         return [this.domain.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) {
@@ -83,7 +83,7 @@ export class RevokeDomainPrivileges extends AlterDomainChange {
     get requires() {
         return [this.domain.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("DOMAIN");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("DOMAIN", list, this.version);
@@ -118,7 +118,7 @@ export class RevokeGrantOptionDomainPrivileges extends AlterDomainChange {
             stableId.acl(this.domain.stableId, this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("DOMAIN");
         const privSql = formatObjectPrivilegeList("DOMAIN", this.privilegeNames, this.version);
         const domainName = `${this.domain.schema}.${this.domain.name}`;

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

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { Domain } from "../domain.model.ts";
+import { CreateDomainChange, DropDomainChange } from "./domain.base.ts";
+export type SecurityLabelDomain = CreateSecurityLabelOnDomain | DropSecurityLabelOnDomain;
+export declare class CreateSecurityLabelOnDomain extends CreateDomainChange {
+    readonly domain: Domain;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        domain: Domain;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `domain:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnDomain extends DropDomainChange {
+    readonly domain: Domain;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        domain: Domain;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `domain:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,61 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateDomainChange, DropDomainChange } from "./domain.base.js";
+export class CreateSecurityLabelOnDomain extends CreateDomainChange {
+    domain;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.domain.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON DOMAIN",
+            `${this.domain.schema}.${this.domain.name}`,
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnDomain extends DropDomainChange {
+    domain;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.domain.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.domain.stableId, this.securityLabel.provider),
+            this.domain.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON DOMAIN",
+            `${this.domain.schema}.${this.domain.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -3,4 +3,6 @@ import type { CommentDomain } from "./domain.comment.ts";
 import type { CreateDomain } from "./domain.create.ts";
 import type { DropDomain } from "./domain.drop.ts";
 import type { DomainPrivilege } from "./domain.privilege.ts";
-export type DomainChange = AlterDomain | CommentDomain | CreateDomain | DropDomain | DomainPrivilege;
+import type { SecurityLabelDomain } from "./domain.security-label.ts";
+/** Union of all domain-related change variants (`objectType: "domain"`). @category Change Types */
+export type DomainChange = AlterDomain | CommentDomain | CreateDomain | DropDomain | DomainPrivilege | SecurityLabelDomain;

package/dist/core/objects/domain/domain.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 { DomainChange } from "./changes/domain.types.ts";
 import type { Domain } from "./domain.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Domain } from "./domain.model.ts";
  * @param branch - The domains in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffDomains(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Domain>, branch: Record<string, Domain>): DomainChange[];
+export declare function diffDomains(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Domain>, branch: Record<string, Domain>): DomainChange[];

package/dist/core/objects/domain/domain.diff.js

@@ -1,10 +1,12 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } from "../base.privilege-diff.js";
+import { diffSecurityLabels } from "../security-label.types.js";
 import { AlterDomainAddConstraint, AlterDomainChangeOwner, AlterDomainDropConstraint, AlterDomainDropDefault, AlterDomainDropNotNull, AlterDomainSetDefault, AlterDomainSetNotNull, AlterDomainValidateConstraint, } from "./changes/domain.alter.js";
 import { CreateCommentOnDomain, DropCommentOnDomain, } from "./changes/domain.comment.js";
 import { CreateDomain } from "./changes/domain.create.js";
 import { DropDomain } from "./changes/domain.drop.js";
 import { GrantDomainPrivileges, RevokeDomainPrivileges, RevokeGrantOptionDomainPrivileges, } from "./changes/domain.privilege.js";
+import { CreateSecurityLabelOnDomain, DropSecurityLabelOnDomain, } from "./changes/domain.security-label.js";
 /**
  * Diff two sets of domains from main and branch catalogs.
  *
@@ -30,6 +32,12 @@ export function diffDomains(ctx, main, branch) {
         if (newDomain.comment !== null) {
             changes.push(new CreateCommentOnDomain({ domain: newDomain }));
         }
+        for (const label of newDomain.security_labels) {
+            changes.push(new CreateSecurityLabelOnDomain({
+                domain: newDomain,
+                securityLabel: label,
+            }));
+        }
         // For unvalidated constraints, CREATE DOMAIN cannot specify NOT VALID.
         // Add them after creation and validate to match branch state semantics.
         // For already validated constraints, they are emitted inline in CREATE DOMAIN.
@@ -50,50 +58,21 @@ export function diffDomains(ctx, main, branch) {
         // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
         // needed to reach the final desired state.
         const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "domain", newDomain.schema ?? "");
+        const creatorFilteredDefaults = newDomain.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
         // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
         // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
         const desiredPrivileges = filterPublicBuiltInDefaults("domain", newDomain.privileges);
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the domain owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, newDomain.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByGrantable(result.grants);
-                for (const [grantable, list] of grantGroups) {
-                    void grantable;
-                    changes.push(new GrantDomainPrivileges({
-                        domain: newDomain,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                for (const [grantable, list] of revokeGroups) {
-                    void grantable;
-                    changes.push(new RevokeDomainPrivileges({
-                        domain: newDomain,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionDomainPrivileges({
-                    domain: newDomain,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("domain", creatorFilteredDefaults), desiredPrivileges, newDomain.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, newDomain, newDomain, "domain", {
+            Grant: GrantDomainPrivileges,
+            Revoke: RevokeDomainPrivileges,
+            RevokeGrantOption: RevokeGrantOptionDomainPrivileges,
+        }, ctx.version));
     }
     for (const domainId of dropped) {
         changes.push(new DropDomain({ domain: main[domainId] }));
@@ -193,6 +172,14 @@ export function diffDomains(ctx, main, branch) {
                 changes.push(new CreateCommentOnDomain({ domain: branchDomain }));
             }
         }
+        // SECURITY LABELS
+        changes.push(...diffSecurityLabels(mainDomain.security_labels, branchDomain.security_labels, (securityLabel) => new CreateSecurityLabelOnDomain({
+            domain: branchDomain,
+            securityLabel,
+        }), (securityLabel) => new DropSecurityLabelOnDomain({
+            domain: mainDomain,
+            securityLabel,
+        })));
         // PRIVILEGES
         // Filter out PUBLIC's built-in default USAGE privilege from main catalog
         // (PostgreSQL grants it automatically, so we shouldn't compare it)
@@ -201,44 +188,12 @@ export function diffDomains(ctx, main, branch) {
         const branchPrivilegesFiltered = filterPublicBuiltInDefaults("domain", branchDomain.privileges);
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use branch owner as the reference.
-        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchDomain.owner, ctx.mainRoles);
-        for (const [grantee, result] of privilegeResults) {
-            // Generate grant changes
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByGrantable(result.grants);
-                for (const [grantable, list] of grantGroups) {
-                    void grantable;
-                    changes.push(new GrantDomainPrivileges({
-                        domain: branchDomain,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                for (const [grantable, list] of revokeGroups) {
-                    void grantable;
-                    changes.push(new RevokeDomainPrivileges({
-                        domain: mainDomain,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionDomainPrivileges({
-                    domain: mainDomain,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchDomain.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchDomain, mainDomain, "domain", {
+            Grant: GrantDomainPrivileges,
+            Revoke: RevokeDomainPrivileges,
+            RevokeGrantOption: RevokeGrantOptionDomainPrivileges,
+        }, ctx.version));
     }
     return changes;
 }

package/dist/core/objects/domain/domain.model.d.ts

@@ -2,6 +2,7 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type SecurityLabelProps } from "../security-label.types.ts";
 declare const domainConstraintPropsSchema: z.ZodObject<{
     name: z.ZodString;
     validated: z.ZodBoolean;
@@ -36,6 +37,10 @@ declare const domainPropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    security_labels: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        label: z.ZodString;
+    }, z.z.core.$strip>>>>;
 }, z.z.core.$strip>;
 export type DomainConstraintProps = z.infer<typeof domainConstraintPropsSchema>;
 type DomainPrivilegeProps = PrivilegeProps;
@@ -61,6 +66,7 @@ export declare class Domain extends BasePgModel {
     readonly comment: DomainProps["comment"];
     readonly constraints: DomainConstraintProps[];
     readonly privileges: DomainPrivilegeProps[];
+    readonly security_labels: SecurityLabelProps[];
     constructor(props: DomainProps);
     get stableId(): `domain:${string}`;
     get identityFields(): {
@@ -91,6 +97,10 @@ export declare class Domain extends BasePgModel {
             grantable: boolean;
             columns?: string[] | null | undefined;
         }[];
+        security_labels: {
+            provider: string;
+            label: string;
+        }[];
     };
 }
 /**

package/dist/core/objects/domain/domain.model.js

@@ -2,6 +2,7 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { securityLabelPropsSchema, } from "../security-label.types.js";
 const domainConstraintPropsSchema = z.object({
     name: z.string(),
     validated: z.boolean(),
@@ -25,6 +26,7 @@ const domainPropsSchema = z.object({
     comment: z.string().nullable(),
     constraints: z.array(domainConstraintPropsSchema),
     privileges: z.array(privilegePropsSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
 });
 /**
  * A domain is a user-defined data type that is based on another underlying type.
@@ -47,6 +49,7 @@ export class Domain extends BasePgModel {
     comment;
     constraints;
     privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -66,6 +69,7 @@ export class Domain extends BasePgModel {
         this.comment = props.comment;
         this.constraints = props.constraints;
         this.privileges = props.privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         return `domain:${this.schema}.${this.name}`;
@@ -90,6 +94,7 @@ export class Domain extends BasePgModel {
             comment: this.comment,
             constraints: this.constraints,
             privileges: this.privileges,
+            security_labels: this.security_labels,
         };
     }
 }
@@ -150,9 +155,22 @@ export async function extractDomains(pool) {
               )
               order by x.grantee, x.privilege_type
             )
-            from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+            from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
           ), '[]'
-        ) 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 = t.oid
+              and sl.classoid = 'pg_type'::regclass
+              and sl.objsubid = 0
+          ),
+          '[]'::json
+        ) as security_labels
       from
         pg_catalog.pg_type t
         inner join pg_catalog.pg_type bt on bt.oid = t.typbasetype

package/dist/core/objects/event-trigger/changes/event-trigger.alter.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { EventTrigger } from "../event-trigger.model.ts";
 import { AlterEventTriggerChange } from "./event-trigger.base.ts";
 /**
@@ -26,7 +27,7 @@ export declare class AlterEventTriggerChangeOwner extends AlterEventTriggerChang
         owner: string;
     });
     get requires(): `eventTrigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER EVENT TRIGGER ... ENABLE/DISABLE ...
@@ -40,5 +41,5 @@ export declare class AlterEventTriggerSetEnabled extends AlterEventTriggerChange
         enabled: EventTrigger["enabled"];
     });
     get requires(): `eventTrigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/event-trigger/changes/event-trigger.alter.js

@@ -14,7 +14,7 @@ export class AlterEventTriggerChangeOwner extends AlterEventTriggerChange {
     get requires() {
         return [this.eventTrigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "ALTER EVENT TRIGGER",
             this.eventTrigger.name,
@@ -44,7 +44,7 @@ export class AlterEventTriggerSetEnabled extends AlterEventTriggerChange {
     get requires() {
         return [this.eventTrigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const clause = ENABLED_SQL[this.enabled];
         return ["ALTER EVENT TRIGGER", this.eventTrigger.name, clause].join(" ");
     }

package/dist/core/objects/event-trigger/changes/event-trigger.base.d.ts

@@ -2,7 +2,7 @@ import { BaseChange } from "../../base.change.ts";
 import type { EventTrigger } from "../event-trigger.model.ts";
 declare abstract class BaseEventTriggerChange extends BaseChange {
     abstract readonly eventTrigger: EventTrigger;
-    abstract readonly scope: "object" | "comment";
+    abstract readonly scope: "object" | "comment" | "security_label";
     readonly objectType: "event_trigger";
 }
 export declare abstract class CreateEventTriggerChange extends BaseEventTriggerChange {

package/dist/core/objects/event-trigger/changes/event-trigger.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { EventTrigger } from "../event-trigger.model.ts";
 import { CreateEventTriggerChange, DropEventTriggerChange } from "./event-trigger.base.ts";
 export type CommentEventTrigger = CreateCommentOnEventTrigger | DropCommentOnEventTrigger;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnEventTrigger extends CreateEventTriggerChang
     });
     get creates(): `comment:${string}`[];
     get requires(): `eventTrigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnEventTrigger extends DropEventTriggerChange {
     readonly eventTrigger: EventTrigger;
@@ -19,5 +20,5 @@ export declare class DropCommentOnEventTrigger extends DropEventTriggerChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `eventTrigger:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/event-trigger/changes/event-trigger.comment.js

@@ -14,7 +14,7 @@ export class CreateCommentOnEventTrigger extends CreateEventTriggerChange {
     get requires() {
         return [this.eventTrigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON EVENT TRIGGER",
             this.eventTrigger.name,
@@ -40,7 +40,7 @@ export class DropCommentOnEventTrigger extends DropEventTriggerChange {
             this.eventTrigger.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         return ["COMMENT ON EVENT TRIGGER", this.eventTrigger.name, "IS NULL"].join(" ");
     }
 }

package/dist/core/objects/event-trigger/changes/event-trigger.create.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { EventTrigger } from "../event-trigger.model.ts";
 import { CreateEventTriggerChange } from "./event-trigger.base.ts";
 /**
@@ -21,5 +22,5 @@ export declare class CreateEventTrigger extends CreateEventTriggerChange {
     });
     get creates(): `eventTrigger:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/event-trigger/changes/event-trigger.create.js

@@ -37,7 +37,7 @@ export class CreateEventTrigger extends CreateEventTriggerChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const parts = [
             "CREATE EVENT TRIGGER",
             this.eventTrigger.name,

package/dist/core/objects/event-trigger/changes/event-trigger.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { EventTrigger } from "../event-trigger.model.ts";
 import { DropEventTriggerChange } from "./event-trigger.base.ts";
 /**
@@ -18,5 +19,5 @@ export declare class DropEventTrigger extends DropEventTriggerChange {
     });
     get drops(): `eventTrigger:${string}`[];
     get requires(): `eventTrigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/event-trigger/changes/event-trigger.drop.js

@@ -22,7 +22,7 @@ export class DropEventTrigger extends DropEventTriggerChange {
     get requires() {
         return [this.eventTrigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return ["DROP EVENT TRIGGER", this.eventTrigger.name].join(" ");
     }
 }

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

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { EventTrigger } from "../event-trigger.model.ts";
+import { CreateEventTriggerChange, DropEventTriggerChange } from "./event-trigger.base.ts";
+export type SecurityLabelEventTrigger = CreateSecurityLabelOnEventTrigger | DropSecurityLabelOnEventTrigger;
+export declare class CreateSecurityLabelOnEventTrigger extends CreateEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `eventTrigger:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnEventTrigger extends DropEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `eventTrigger:${string}`)[];
+    serialize(): string;
+}