@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

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

@@ -0,0 +1,244 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.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";
+/**
+ * Diff two sets of domains from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The domains in the main catalog.
+ * @param branch - The domains in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffDomains(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const domainId of created) {
+        const newDomain = branch[domainId];
+        changes.push(new CreateDomain({ domain: newDomain }));
+        // OWNER: If the domain should be owned by someone other than the current user,
+        // emit ALTER DOMAIN ... OWNER TO after creation
+        if (newDomain.owner !== ctx.currentUser) {
+            changes.push(new AlterDomainChangeOwner({
+                domain: newDomain,
+                owner: newDomain.owner,
+            }));
+        }
+        if (newDomain.comment !== null) {
+            changes.push(new CreateCommentOnDomain({ domain: newDomain }));
+        }
+        // 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.
+        if (newDomain.constraints && newDomain.constraints.length > 0) {
+            for (const c of newDomain.constraints) {
+                if (c.validated === false) {
+                    changes.push(new AlterDomainAddConstraint({ domain: newDomain, constraint: c }));
+                    changes.push(new AlterDomainValidateConstraint({
+                        domain: newDomain,
+                        constraint: c,
+                    }));
+                }
+            }
+        }
+        // PRIVILEGES: For created objects, compare against default privileges state
+        // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+        // so objects are created with the default privileges state in effect.
+        // 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 ?? "");
+        // 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,
+                }));
+            }
+        }
+    }
+    for (const domainId of dropped) {
+        changes.push(new DropDomain({ domain: main[domainId] }));
+    }
+    for (const domainId of altered) {
+        const mainDomain = main[domainId];
+        const branchDomain = branch[domainId];
+        // DEFAULT
+        if (mainDomain.default_value !== branchDomain.default_value) {
+            if (branchDomain.default_value === null) {
+                changes.push(new AlterDomainDropDefault({ domain: mainDomain }));
+            }
+            else {
+                changes.push(new AlterDomainSetDefault({
+                    domain: mainDomain,
+                    defaultValue: branchDomain.default_value,
+                }));
+            }
+        }
+        // NOT NULL
+        if (mainDomain.not_null !== branchDomain.not_null) {
+            if (branchDomain.not_null) {
+                changes.push(new AlterDomainSetNotNull({ domain: mainDomain }));
+            }
+            else {
+                changes.push(new AlterDomainDropNotNull({ domain: mainDomain }));
+            }
+        }
+        // DOMAIN CONSTRAINTS
+        const mainByName = new Map(mainDomain.constraints.map((c) => [c.name, c]));
+        const branchByName = new Map(branchDomain.constraints.map((c) => [c.name, c]));
+        // Note: Constraint renames are modeled as drop+add because name is part
+        // of the identity we diff on. No dedicated rename class is generated here.
+        // Created
+        for (const [name, c] of branchByName) {
+            if (!mainByName.has(name)) {
+                changes.push(new AlterDomainAddConstraint({
+                    domain: branchDomain,
+                    constraint: c,
+                }));
+                if (!c.validated) {
+                    changes.push(new AlterDomainValidateConstraint({
+                        domain: branchDomain,
+                        constraint: c,
+                    }));
+                }
+            }
+        }
+        // Dropped
+        for (const [name, c] of mainByName) {
+            if (!branchByName.has(name)) {
+                changes.push(new AlterDomainDropConstraint({
+                    domain: mainDomain,
+                    constraint: c,
+                }));
+            }
+        }
+        // Altered (drop + add for now)
+        for (const [name, mainC] of mainByName) {
+            const branchC = branchByName.get(name);
+            if (!branchC)
+                continue;
+            const changed = mainC.validated !== branchC.validated ||
+                mainC.is_local !== branchC.is_local ||
+                mainC.no_inherit !== branchC.no_inherit ||
+                mainC.check_expression !== branchC.check_expression;
+            if (changed) {
+                changes.push(new AlterDomainDropConstraint({
+                    domain: mainDomain,
+                    constraint: mainC,
+                }));
+                changes.push(new AlterDomainAddConstraint({
+                    domain: branchDomain,
+                    constraint: branchC,
+                }));
+                if (!branchC.validated) {
+                    changes.push(new AlterDomainValidateConstraint({
+                        domain: branchDomain,
+                        constraint: branchC,
+                    }));
+                }
+            }
+        }
+        // OWNER
+        if (mainDomain.owner !== branchDomain.owner) {
+            changes.push(new AlterDomainChangeOwner({
+                domain: mainDomain,
+                owner: branchDomain.owner,
+            }));
+        }
+        // COMMENT
+        if (mainDomain.comment !== branchDomain.comment) {
+            if (branchDomain.comment === null) {
+                changes.push(new DropCommentOnDomain({ domain: mainDomain }));
+            }
+            else {
+                changes.push(new CreateCommentOnDomain({ domain: branchDomain }));
+            }
+        }
+        // PRIVILEGES
+        // Filter out PUBLIC's built-in default USAGE privilege from main catalog
+        // (PostgreSQL grants it automatically, so we shouldn't compare it)
+        const mainPrivilegesFiltered = filterPublicBuiltInDefaults("domain", mainDomain.privileges);
+        // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+        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,
+                }));
+            }
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,103 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+declare const domainConstraintPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    validated: z.ZodBoolean;
+    is_local: z.ZodBoolean;
+    no_inherit: z.ZodBoolean;
+    check_expression: z.ZodNullable<z.ZodString>;
+}, z.z.core.$strip>;
+declare const domainPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    base_type: z.ZodString;
+    base_type_schema: z.ZodString;
+    base_type_str: z.ZodOptional<z.ZodString>;
+    not_null: z.ZodBoolean;
+    type_modifier: z.ZodNullable<z.ZodNumber>;
+    array_dimensions: z.ZodNullable<z.ZodNumber>;
+    collation: z.ZodNullable<z.ZodString>;
+    default_bin: z.ZodNullable<z.ZodString>;
+    default_value: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    constraints: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        validated: z.ZodBoolean;
+        is_local: z.ZodBoolean;
+        no_inherit: z.ZodBoolean;
+        check_expression: z.ZodNullable<z.ZodString>;
+    }, z.z.core.$strip>>;
+    privileges: z.ZodArray<z.ZodObject<{
+        grantee: z.ZodString;
+        privilege: z.ZodString;
+        grantable: z.ZodBoolean;
+        columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+export type DomainConstraintProps = z.infer<typeof domainConstraintPropsSchema>;
+type DomainPrivilegeProps = PrivilegeProps;
+export type DomainProps = z.infer<typeof domainPropsSchema>;
+/**
+ * A domain is a user-defined data type that is based on another underlying type.
+ *
+ * @see https://www.postgresql.org/docs/17/domains.html
+ */
+export declare class Domain extends BasePgModel {
+    readonly schema: DomainProps["schema"];
+    readonly name: DomainProps["name"];
+    readonly base_type: DomainProps["base_type"];
+    readonly base_type_schema: DomainProps["base_type_schema"];
+    readonly base_type_str?: DomainProps["base_type_str"];
+    readonly not_null: DomainProps["not_null"];
+    readonly type_modifier: DomainProps["type_modifier"];
+    readonly array_dimensions: DomainProps["array_dimensions"];
+    readonly collation: DomainProps["collation"];
+    readonly default_bin: DomainProps["default_bin"];
+    readonly default_value: DomainProps["default_value"];
+    readonly owner: DomainProps["owner"];
+    readonly comment: DomainProps["comment"];
+    readonly constraints: DomainConstraintProps[];
+    readonly privileges: DomainPrivilegeProps[];
+    constructor(props: DomainProps);
+    get stableId(): `domain:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        base_type: string;
+        base_type_schema: string;
+        not_null: boolean;
+        type_modifier: number | null;
+        array_dimensions: number | null;
+        collation: string | null;
+        default_bin: string | null;
+        default_value: string | null;
+        owner: string;
+        comment: string | null;
+        constraints: {
+            name: string;
+            validated: boolean;
+            is_local: boolean;
+            no_inherit: boolean;
+            check_expression: string | null;
+        }[];
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+/**
+ * Extract all domains from the database.
+ *
+ * @param sql - The SQL client.
+ * @returns A list of domains.
+ */
+export declare function extractDomains(sql: Sql): Promise<Domain[]>;
+export {};

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

@@ -0,0 +1,172 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+const domainConstraintPropsSchema = z.object({
+    name: z.string(),
+    validated: z.boolean(),
+    is_local: z.boolean(),
+    no_inherit: z.boolean(),
+    check_expression: z.string().nullable(),
+});
+const domainPropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    base_type: z.string(),
+    base_type_schema: z.string(),
+    base_type_str: z.string().optional(),
+    not_null: z.boolean(),
+    type_modifier: z.number().nullable(),
+    array_dimensions: z.number().nullable(),
+    collation: z.string().nullable(),
+    default_bin: z.string().nullable(),
+    default_value: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    constraints: z.array(domainConstraintPropsSchema),
+    privileges: z.array(privilegePropsSchema),
+});
+/**
+ * A domain is a user-defined data type that is based on another underlying type.
+ *
+ * @see https://www.postgresql.org/docs/17/domains.html
+ */
+export class Domain extends BasePgModel {
+    schema;
+    name;
+    base_type;
+    base_type_schema;
+    base_type_str;
+    not_null;
+    type_modifier;
+    array_dimensions;
+    collation;
+    default_bin;
+    default_value;
+    owner;
+    comment;
+    constraints;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.base_type = props.base_type;
+        this.base_type_schema = props.base_type_schema;
+        this.base_type_str = props.base_type_str;
+        this.not_null = props.not_null;
+        this.type_modifier = props.type_modifier;
+        this.array_dimensions = props.array_dimensions;
+        this.collation = props.collation;
+        this.default_bin = props.default_bin;
+        this.default_value = props.default_value;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.constraints = props.constraints;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `domain:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            base_type: this.base_type,
+            base_type_schema: this.base_type_schema,
+            not_null: this.not_null,
+            type_modifier: this.type_modifier,
+            array_dimensions: this.array_dimensions,
+            collation: this.collation,
+            default_bin: this.default_bin,
+            default_value: this.default_value,
+            owner: this.owner,
+            comment: this.comment,
+            constraints: this.constraints,
+            privileges: this.privileges,
+        };
+    }
+}
+/**
+ * Extract all domains from the database.
+ *
+ * @param sql - The SQL client.
+ * @returns A list of domains.
+ */
+export async function extractDomains(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const domainRows = await sql `
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_type'::regclass
+      )
+      select
+        t.typnamespace::regnamespace::text as schema,
+        quote_ident(t.typname) as name,
+        bt.typname as base_type,
+        bt.typnamespace::regnamespace::text as base_type_schema,
+        format_type(t.typbasetype, t.typtypmod) as base_type_str,
+        t.typnotnull as not_null,
+        t.typtypmod as type_modifier,
+        t.typndims as array_dimensions,
+        case when t.typcollation <> bt.typcollation then quote_ident(c.collname) else null end as collation,
+        pg_get_expr(t.typdefaultbin, 0) as default_bin,
+        t.typdefault as default_value,
+        t.typowner::regrole::text as owner,
+        obj_description(t.oid, 'pg_type') as comment,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object(
+                'name', quote_ident(con.conname),
+                'validated', con.convalidated,
+                'is_local', con.conislocal,
+                'no_inherit', con.connoinherit,
+                'check_expression', pg_get_expr(con.conbin, 0)
+              )
+              order by con.conname
+            )
+            from pg_catalog.pg_constraint con
+            where con.contypid = t.oid
+          ), '[]'
+        ) as constraints,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object(
+                'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+                'privilege', x.privilege_type,
+                'grantable', x.is_grantable
+              )
+              order by x.grantee, x.privilege_type
+            )
+            from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+          ), '[]'
+        ) as privileges
+      from
+        pg_catalog.pg_type t
+        inner join pg_catalog.pg_type bt on bt.oid = t.typbasetype
+        left join pg_catalog.pg_collation c on c.oid = t.typcollation
+        left outer join extension_oids e on t.oid = e.objid
+        where not t.typnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+        and t.typtype = 'd'
+      order by
+        1, 2;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = domainRows.map((row) => domainPropsSchema.parse(row));
+        return validatedRows.map((row) => new Domain(row));
+    });
+}

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

@@ -0,0 +1,44 @@
+import type { EventTrigger } from "../event-trigger.model.ts";
+import { AlterEventTriggerChange } from "./event-trigger.base.ts";
+/**
+ * Alter an event trigger.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altereventtrigger.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER EVENT TRIGGER name DISABLE
+ * ALTER EVENT TRIGGER name ENABLE [ REPLICA | ALWAYS ]
+ * ALTER EVENT TRIGGER name OWNER TO { newowner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER EVENT TRIGGER name RENAME TO newname
+ * ```
+ */
+export type AlterEventTrigger = AlterEventTriggerChangeOwner | AlterEventTriggerSetEnabled;
+/**
+ * ALTER EVENT TRIGGER ... OWNER TO ...
+ */
+export declare class AlterEventTriggerChangeOwner extends AlterEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+        owner: string;
+    });
+    get requires(): `eventTrigger:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER EVENT TRIGGER ... ENABLE/DISABLE ...
+ */
+export declare class AlterEventTriggerSetEnabled extends AlterEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly enabled: EventTrigger["enabled"];
+    readonly scope: "object";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+        enabled: EventTrigger["enabled"];
+    });
+    get requires(): `eventTrigger:${string}`[];
+    serialize(): string;
+}

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

@@ -0,0 +1,51 @@
+import { AlterEventTriggerChange } from "./event-trigger.base.js";
+/**
+ * ALTER EVENT TRIGGER ... OWNER TO ...
+ */
+export class AlterEventTriggerChangeOwner extends AlterEventTriggerChange {
+    eventTrigger;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.eventTrigger = props.eventTrigger;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.eventTrigger.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER EVENT TRIGGER",
+            this.eventTrigger.name,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+const ENABLED_SQL = {
+    O: "ENABLE",
+    D: "DISABLE",
+    R: "ENABLE REPLICA",
+    A: "ENABLE ALWAYS",
+};
+/**
+ * ALTER EVENT TRIGGER ... ENABLE/DISABLE ...
+ */
+export class AlterEventTriggerSetEnabled extends AlterEventTriggerChange {
+    eventTrigger;
+    enabled;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.eventTrigger = props.eventTrigger;
+        this.enabled = props.enabled;
+    }
+    get requires() {
+        return [this.eventTrigger.stableId];
+    }
+    serialize() {
+        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

@@ -0,0 +1,17 @@
+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";
+    readonly objectType: "event_trigger";
+}
+export declare abstract class CreateEventTriggerChange extends BaseEventTriggerChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterEventTriggerChange extends BaseEventTriggerChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropEventTriggerChange extends BaseEventTriggerChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseEventTriggerChange extends BaseChange {
+    objectType = "event_trigger";
+}
+export class CreateEventTriggerChange extends BaseEventTriggerChange {
+    operation = "create";
+}
+export class AlterEventTriggerChange extends BaseEventTriggerChange {
+    operation = "alter";
+}
+export class DropEventTriggerChange extends BaseEventTriggerChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,23 @@
+import type { EventTrigger } from "../event-trigger.model.ts";
+import { CreateEventTriggerChange, DropEventTriggerChange } from "./event-trigger.base.ts";
+export type CommentEventTrigger = CreateCommentOnEventTrigger | DropCommentOnEventTrigger;
+export declare class CreateCommentOnEventTrigger extends CreateEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly scope: "comment";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `eventTrigger:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnEventTrigger extends DropEventTriggerChange {
+    readonly eventTrigger: EventTrigger;
+    readonly scope: "comment";
+    constructor(props: {
+        eventTrigger: EventTrigger;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `eventTrigger:${string}`)[];
+    serialize(): string;
+}