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

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.d.ts

@@ -0,0 +1,59 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../../base.model.ts";
+import { type PrivilegeProps } from "../../base.privilege-diff.ts";
+/**
+ * All properties exposed by CREATE FOREIGN DATA WRAPPER statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createforeigndatawrapper.html
+ *
+ * ALTER FOREIGN DATA WRAPPER statement can be generated for changes to the following properties:
+ *  - owner, handler, validator, options
+ * https://www.postgresql.org/docs/17/sql-alterforeigndatawrapper.html
+ *
+ * Foreign Data Wrappers are not schema-qualified (no schema property).
+ */
+declare const foreignDataWrapperPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    owner: z.ZodString;
+    handler: z.ZodNullable<z.ZodString>;
+    validator: z.ZodNullable<z.ZodString>;
+    options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    comment: z.ZodNullable<z.ZodString>;
+    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>;
+type ForeignDataWrapperPrivilegeProps = PrivilegeProps;
+export type ForeignDataWrapperProps = z.infer<typeof foreignDataWrapperPropsSchema>;
+export declare class ForeignDataWrapper extends BasePgModel {
+    readonly name: ForeignDataWrapperProps["name"];
+    readonly owner: ForeignDataWrapperProps["owner"];
+    readonly handler: ForeignDataWrapperProps["handler"];
+    readonly validator: ForeignDataWrapperProps["validator"];
+    readonly options: ForeignDataWrapperProps["options"];
+    readonly comment: ForeignDataWrapperProps["comment"];
+    readonly privileges: ForeignDataWrapperPrivilegeProps[];
+    constructor(props: ForeignDataWrapperProps);
+    get stableId(): `foreignDataWrapper:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        owner: string;
+        handler: string | null;
+        validator: string | null;
+        options: string[] | null;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+export declare function extractForeignDataWrappers(sql: Sql): Promise<ForeignDataWrapper[]>;
+export {};

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.model.js

@@ -0,0 +1,128 @@
+import z from "zod";
+import { BasePgModel } from "../../base.model.js";
+import { privilegePropsSchema, } from "../../base.privilege-diff.js";
+/**
+ * All properties exposed by CREATE FOREIGN DATA WRAPPER statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createforeigndatawrapper.html
+ *
+ * ALTER FOREIGN DATA WRAPPER statement can be generated for changes to the following properties:
+ *  - owner, handler, validator, options
+ * https://www.postgresql.org/docs/17/sql-alterforeigndatawrapper.html
+ *
+ * Foreign Data Wrappers are not schema-qualified (no schema property).
+ */
+const foreignDataWrapperPropsSchema = z.object({
+    name: z.string(),
+    owner: z.string(),
+    handler: z.string().nullable(),
+    validator: z.string().nullable(),
+    options: z.array(z.string()).nullable(),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class ForeignDataWrapper extends BasePgModel {
+    name;
+    owner;
+    handler;
+    validator;
+    options;
+    comment;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.name = props.name;
+        // Data fields
+        this.owner = props.owner;
+        this.handler = props.handler;
+        this.validator = props.validator;
+        this.options = props.options;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `foreignDataWrapper:${this.name}`;
+    }
+    get identityFields() {
+        return {
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            owner: this.owner,
+            handler: this.handler,
+            validator: this.validator,
+            options: this.options,
+            comment: this.comment,
+            privileges: this.privileges,
+        };
+    }
+}
+export async function extractForeignDataWrappers(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const fdwRows = await sql `
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_foreign_data_wrapper'::regclass
+      )
+      select
+        quote_ident(fdw.fdwname) as name,
+        fdw.fdwowner::regrole::text as owner,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname) || '(' || pg_get_function_identity_arguments(fdw.fdwhandler) || ')'
+        end as handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname) || '(' || pg_get_function_identity_arguments(fdw.fdwvalidator) || ')'
+        end as validator,
+        coalesce(fdw.fdwoptions, array[]::text[]) as options,
+        obj_description(fdw.oid, 'pg_foreign_data_wrapper') as comment,
+        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(fdw.fdwacl) as x(grantor, grantee, privilege_type, is_grantable)
+          ), '[]'
+        ) as privileges
+      from
+        pg_catalog.pg_foreign_data_wrapper fdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
+        left join extension_oids e on fdw.oid = e.objid
+      where
+        not fdw.fdwname like any(array['pg\\_%'])
+        and e.objid is null
+      order by
+        fdw.fdwname;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = fdwRows.map((row) => {
+            const parsed = foreignDataWrapperPropsSchema.parse(row);
+            // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+            if (parsed.options && parsed.options.length > 0) {
+                const parsedOptions = [];
+                for (const opt of parsed.options) {
+                    const eqIndex = opt.indexOf("=");
+                    if (eqIndex > 0) {
+                        parsedOptions.push(opt.substring(0, eqIndex));
+                        parsedOptions.push(opt.substring(eqIndex + 1));
+                    }
+                }
+                parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+            }
+            return parsed;
+        });
+        return validatedRows.map((row) => new ForeignDataWrapper(row));
+    });
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper.types.d.ts

@@ -0,0 +1,5 @@
+import type { ForeignDataWrapperChange as FDWChange } from "./foreign-data-wrapper/changes/foreign-data-wrapper.types.ts";
+import type { ForeignTableChange } from "./foreign-table/changes/foreign-table.types.ts";
+import type { ServerChange } from "./server/changes/server.types.ts";
+import type { UserMappingChange } from "./user-mapping/changes/user-mapping.types.ts";
+export type ForeignDataWrapperChange = FDWChange | ServerChange | UserMappingChange | ForeignTableChange;

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.alter.d.ts

@@ -0,0 +1,163 @@
+import type { ColumnProps } from "../../../base.model.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { AlterForeignTableChange } from "./foreign-table.base.ts";
+/**
+ * Alter a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER FOREIGN TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ *     action [, ... ]
+ * where action is one of:
+ *     ADD [ COLUMN ] [ IF NOT EXISTS ] column_name data_type [ OPTIONS ( option 'value' [, ... ] ) ] [ COLLATE collation ] [ column_constraint [ ... ] ]
+ *     DROP [ COLUMN ] [ IF EXISTS ] column_name [ RESTRICT | CASCADE ]
+ *     ALTER [ COLUMN ] column_name [ SET DATA ] TYPE data_type [ COLLATE collation ]
+ *     ALTER [ COLUMN ] column_name SET DEFAULT expression
+ *     ALTER [ COLUMN ] column_name DROP DEFAULT
+ *     ALTER [ COLUMN ] column_name { SET | DROP } NOT NULL
+ *     ALTER [ COLUMN ] column_name OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ *     OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ *     OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ * ```
+ */
+export type AlterForeignTable = AlterForeignTableChangeOwner | AlterForeignTableAddColumn | AlterForeignTableDropColumn | AlterForeignTableAlterColumnType | AlterForeignTableAlterColumnSetDefault | AlterForeignTableAlterColumnDropDefault | AlterForeignTableAlterColumnSetNotNull | AlterForeignTableAlterColumnDropNotNull | AlterForeignTableSetOptions;
+/**
+ * ALTER FOREIGN TABLE ... OWNER TO ...
+ */
+export declare class AlterForeignTableChangeOwner extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        owner: string;
+    });
+    get requires(): (`role:${string}` | `foreignTable:${string}`)[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... ADD COLUMN ...
+ */
+export declare class AlterForeignTableAddColumn extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly column: ColumnProps;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        column: ColumnProps;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... DROP COLUMN ...
+ */
+export declare class AlterForeignTableDropColumn extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly columnName: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        columnName: string;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... TYPE ...
+ */
+export declare class AlterForeignTableAlterColumnType extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly columnName: string;
+    readonly dataType: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        columnName: string;
+        dataType: string;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... SET DEFAULT ...
+ */
+export declare class AlterForeignTableAlterColumnSetDefault extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly columnName: string;
+    readonly defaultValue: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        columnName: string;
+        defaultValue: string;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... DROP DEFAULT
+ */
+export declare class AlterForeignTableAlterColumnDropDefault extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly columnName: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        columnName: string;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... SET NOT NULL
+ */
+export declare class AlterForeignTableAlterColumnSetNotNull extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly columnName: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        columnName: string;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... DROP NOT NULL
+ */
+export declare class AlterForeignTableAlterColumnDropNotNull extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly columnName: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        columnName: string;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN TABLE ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export declare class AlterForeignTableSetOptions extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly options: Array<{
+        action: "ADD" | "SET" | "DROP";
+        option: string;
+        value?: string;
+    }>;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        options: Array<{
+            action: "ADD" | "SET" | "DROP";
+            option: string;
+            value?: string;
+        }>;
+    });
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.alter.js

@@ -0,0 +1,248 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { AlterForeignTableChange } from "./foreign-table.base.js";
+/**
+ * ALTER FOREIGN TABLE ... OWNER TO ...
+ */
+export class AlterForeignTableChangeOwner extends AlterForeignTableChange {
+    foreignTable;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.foreignTable.stableId, stableId.role(this.owner)];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... ADD COLUMN ...
+ */
+export class AlterForeignTableAddColumn extends AlterForeignTableChange {
+    foreignTable;
+    column;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.column = props.column;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        const parts = [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "ADD COLUMN",
+            this.column.name,
+            this.column.data_type_str,
+        ];
+        if (this.column.not_null) {
+            parts.push("NOT NULL");
+        }
+        if (this.column.default) {
+            parts.push("DEFAULT", this.column.default);
+        }
+        return parts.join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... DROP COLUMN ...
+ */
+export class AlterForeignTableDropColumn extends AlterForeignTableChange {
+    foreignTable;
+    columnName;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.columnName = props.columnName;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "DROP COLUMN",
+            this.columnName,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... TYPE ...
+ */
+export class AlterForeignTableAlterColumnType extends AlterForeignTableChange {
+    foreignTable;
+    columnName;
+    dataType;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.columnName = props.columnName;
+        this.dataType = props.dataType;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "ALTER COLUMN",
+            this.columnName,
+            "TYPE",
+            this.dataType,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... SET DEFAULT ...
+ */
+export class AlterForeignTableAlterColumnSetDefault extends AlterForeignTableChange {
+    foreignTable;
+    columnName;
+    defaultValue;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.columnName = props.columnName;
+        this.defaultValue = props.defaultValue;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "ALTER COLUMN",
+            this.columnName,
+            "SET DEFAULT",
+            this.defaultValue,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... DROP DEFAULT
+ */
+export class AlterForeignTableAlterColumnDropDefault extends AlterForeignTableChange {
+    foreignTable;
+    columnName;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.columnName = props.columnName;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "ALTER COLUMN",
+            this.columnName,
+            "DROP DEFAULT",
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... SET NOT NULL
+ */
+export class AlterForeignTableAlterColumnSetNotNull extends AlterForeignTableChange {
+    foreignTable;
+    columnName;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.columnName = props.columnName;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "ALTER COLUMN",
+            this.columnName,
+            "SET NOT NULL",
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... DROP NOT NULL
+ */
+export class AlterForeignTableAlterColumnDropNotNull extends AlterForeignTableChange {
+    foreignTable;
+    columnName;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.columnName = props.columnName;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "ALTER COLUMN",
+            this.columnName,
+            "DROP NOT NULL",
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN TABLE ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export class AlterForeignTableSetOptions extends AlterForeignTableChange {
+    foreignTable;
+    options;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.options = props.options;
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        const optionParts = [];
+        for (const opt of this.options) {
+            if (opt.action === "DROP") {
+                optionParts.push(`DROP ${opt.option}`);
+            }
+            else {
+                const value = opt.value !== undefined ? quoteLiteral(opt.value) : "''";
+                optionParts.push(`${opt.action} ${opt.option} ${value}`);
+            }
+        }
+        return [
+            "ALTER FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "OPTIONS",
+            `(${optionParts.join(", ")})`,
+        ].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+declare abstract class BaseForeignTableChange extends BaseChange {
+    abstract readonly foreignTable: ForeignTable;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "foreign_table";
+}
+export declare abstract class CreateForeignTableChange extends BaseForeignTableChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterForeignTableChange extends BaseForeignTableChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropForeignTableChange extends BaseForeignTableChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../../base.change.js";
+class BaseForeignTableChange extends BaseChange {
+    objectType = "foreign_table";
+}
+export class CreateForeignTableChange extends BaseForeignTableChange {
+    operation = "create";
+}
+export class AlterForeignTableChange extends BaseForeignTableChange {
+    operation = "alter";
+}
+export class DropForeignTableChange extends BaseForeignTableChange {
+    operation = "drop";
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.comment.d.ts

@@ -0,0 +1,26 @@
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { CreateForeignTableChange, DropForeignTableChange } from "./foreign-table.base.ts";
+/**
+ * Create/drop comments on foreign tables.
+ */
+export type CommentForeignTable = CreateCommentOnForeignTable | DropCommentOnForeignTable;
+export declare class CreateCommentOnForeignTable extends CreateForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly scope: "comment";
+    constructor(props: {
+        foreignTable: ForeignTable;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `foreignTable:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnForeignTable extends DropForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly scope: "comment";
+    constructor(props: {
+        foreignTable: ForeignTable;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `foreignTable:${string}`)[];
+    serialize(): string;
+}