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

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

@@ -0,0 +1,268 @@
+import { diffObjects } from "../../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { AlterForeignTableAddColumn, AlterForeignTableAlterColumnDropDefault, AlterForeignTableAlterColumnDropNotNull, AlterForeignTableAlterColumnSetDefault, AlterForeignTableAlterColumnSetNotNull, AlterForeignTableAlterColumnType, AlterForeignTableChangeOwner, AlterForeignTableDropColumn, AlterForeignTableSetOptions, } from "./changes/foreign-table.alter.js";
+import { CreateCommentOnForeignTable, DropCommentOnForeignTable, } from "./changes/foreign-table.comment.js";
+import { CreateForeignTable } from "./changes/foreign-table.create.js";
+import { DropForeignTable } from "./changes/foreign-table.drop.js";
+import { GrantForeignTablePrivileges, RevokeForeignTablePrivileges, RevokeGrantOptionForeignTablePrivileges, } from "./changes/foreign-table.privilege.js";
+/**
+ * Diff two sets of foreign tables from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The foreign tables in the main catalog.
+ * @param branch - The foreign tables in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffForeignTables(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const tableId of created) {
+        const createdTable = branch[tableId];
+        changes.push(new CreateForeignTable({ foreignTable: createdTable }));
+        // OWNER: If the table should be owned by someone other than the current user,
+        // emit ALTER FOREIGN TABLE ... OWNER TO after creation
+        if (createdTable.owner !== ctx.currentUser) {
+            changes.push(new AlterForeignTableChangeOwner({
+                foreignTable: createdTable,
+                owner: createdTable.owner,
+            }));
+        }
+        if (createdTable.comment !== null) {
+            changes.push(new CreateCommentOnForeignTable({ foreignTable: createdTable }));
+        }
+        // PRIVILEGES: For created objects, compare against default privileges state
+        const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "foreign_table", createdTable.schema ?? "");
+        const desiredPrivileges = filterPublicBuiltInDefaults("foreign_table", createdTable.privileges);
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdTable.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 GrantForeignTablePrivileges({
+                        foreignTable: createdTable,
+                        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 RevokeForeignTablePrivileges({
+                        foreignTable: createdTable,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionForeignTablePrivileges({
+                    foreignTable: createdTable,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const tableId of dropped) {
+        changes.push(new DropForeignTable({ foreignTable: main[tableId] }));
+    }
+    for (const tableId of altered) {
+        const mainTable = main[tableId];
+        const branchTable = branch[tableId];
+        // OWNER
+        if (mainTable.owner !== branchTable.owner) {
+            changes.push(new AlterForeignTableChangeOwner({
+                foreignTable: mainTable,
+                owner: branchTable.owner,
+            }));
+        }
+        // SERVER - if changed, need to recreate (not directly alterable)
+        if (mainTable.server !== branchTable.server) {
+            changes.push(new DropForeignTable({ foreignTable: mainTable }));
+            changes.push(new CreateForeignTable({ foreignTable: branchTable }));
+            if (branchTable.comment !== null) {
+                changes.push(new CreateCommentOnForeignTable({ foreignTable: branchTable }));
+            }
+            continue;
+        }
+        // COLUMNS
+        const mainColumnsByName = new Map(mainTable.columns.map((c) => [c.name, c]));
+        const branchColumnsByName = new Map(branchTable.columns.map((c) => [c.name, c]));
+        // Added columns
+        for (const [name, col] of branchColumnsByName) {
+            if (!mainColumnsByName.has(name)) {
+                changes.push(new AlterForeignTableAddColumn({
+                    foreignTable: mainTable,
+                    column: col,
+                }));
+            }
+        }
+        // Dropped columns
+        for (const [name] of mainColumnsByName) {
+            if (!branchColumnsByName.has(name)) {
+                changes.push(new AlterForeignTableDropColumn({
+                    foreignTable: mainTable,
+                    columnName: name,
+                }));
+            }
+        }
+        // Altered columns
+        for (const [name, mainCol] of mainColumnsByName) {
+            const branchCol = branchColumnsByName.get(name);
+            if (!branchCol)
+                continue;
+            // Type change
+            if (mainCol.data_type_str !== branchCol.data_type_str) {
+                changes.push(new AlterForeignTableAlterColumnType({
+                    foreignTable: mainTable,
+                    columnName: name,
+                    dataType: branchCol.data_type_str,
+                }));
+            }
+            // Default change
+            if (mainCol.default !== branchCol.default) {
+                if (branchCol.default === null) {
+                    changes.push(new AlterForeignTableAlterColumnDropDefault({
+                        foreignTable: mainTable,
+                        columnName: name,
+                    }));
+                }
+                else {
+                    changes.push(new AlterForeignTableAlterColumnSetDefault({
+                        foreignTable: mainTable,
+                        columnName: name,
+                        defaultValue: branchCol.default,
+                    }));
+                }
+            }
+            // NOT NULL change
+            if (mainCol.not_null !== branchCol.not_null) {
+                if (branchCol.not_null) {
+                    changes.push(new AlterForeignTableAlterColumnSetNotNull({
+                        foreignTable: mainTable,
+                        columnName: name,
+                    }));
+                }
+                else {
+                    changes.push(new AlterForeignTableAlterColumnDropNotNull({
+                        foreignTable: mainTable,
+                        columnName: name,
+                    }));
+                }
+            }
+        }
+        // OPTIONS
+        const optionsChanged = diffOptions(mainTable.options, branchTable.options);
+        if (optionsChanged.length > 0) {
+            changes.push(new AlterForeignTableSetOptions({
+                foreignTable: mainTable,
+                options: optionsChanged,
+            }));
+        }
+        // COMMENT
+        if (mainTable.comment !== branchTable.comment) {
+            if (branchTable.comment === null) {
+                changes.push(new DropCommentOnForeignTable({ foreignTable: mainTable }));
+            }
+            else {
+                changes.push(new CreateCommentOnForeignTable({ foreignTable: branchTable }));
+            }
+        }
+        // PRIVILEGES
+        const mainPrivilegesFiltered = filterPublicBuiltInDefaults("foreign_table", mainTable.privileges);
+        const branchPrivilegesFiltered = filterPublicBuiltInDefaults("foreign_table", branchTable.privileges);
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchTable.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 GrantForeignTablePrivileges({
+                        foreignTable: branchTable,
+                        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 RevokeForeignTablePrivileges({
+                        foreignTable: mainTable,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionForeignTablePrivileges({
+                    foreignTable: mainTable,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+        // Note: Foreign table renaming would also use ALTER FOREIGN TABLE ... RENAME TO ...
+        // But since our ForeignTable model uses 'name' as the identity field,
+        // a name change would be handled as drop + create by diffObjects()
+    }
+    return changes;
+}
+/**
+ * Diff options arrays to determine ADD/SET/DROP operations.
+ * Options are stored as [key1, value1, key2, value2, ...]
+ */
+function diffOptions(mainOptions, branchOptions) {
+    const mainMap = new Map();
+    const branchMap = new Map();
+    // Parse main options
+    if (mainOptions) {
+        for (let i = 0; i < mainOptions.length; i += 2) {
+            if (i + 1 < mainOptions.length) {
+                mainMap.set(mainOptions[i], mainOptions[i + 1]);
+            }
+        }
+    }
+    // Parse branch options
+    if (branchOptions) {
+        for (let i = 0; i < branchOptions.length; i += 2) {
+            if (i + 1 < branchOptions.length) {
+                branchMap.set(branchOptions[i], branchOptions[i + 1]);
+            }
+        }
+    }
+    const changes = [];
+    // Find options to ADD or SET
+    for (const [key, value] of branchMap) {
+        const mainValue = mainMap.get(key);
+        if (mainValue === undefined) {
+            changes.push({ action: "ADD", option: key, value });
+        }
+        else if (mainValue !== value) {
+            changes.push({ action: "SET", option: key, value });
+        }
+    }
+    // Find options to DROP
+    for (const [key] of mainMap) {
+        if (!branchMap.has(key)) {
+            changes.push({ action: "DROP", option: key });
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,117 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel, type TableLikeObject } from "../../base.model.ts";
+import { type PrivilegeProps } from "../../base.privilege-diff.ts";
+/**
+ * All properties exposed by CREATE FOREIGN TABLE statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createforeigntable.html
+ *
+ * ALTER FOREIGN TABLE statement can be generated for changes to the following properties:
+ *  - owner, columns, options
+ * https://www.postgresql.org/docs/17/sql-alterforeigntable.html
+ *
+ * Foreign tables are schema-qualified and similar to regular tables but reference a server.
+ */
+declare const foreignTablePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    server: z.ZodString;
+    options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    comment: z.ZodNullable<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        position: z.ZodNumber;
+        data_type: z.ZodString;
+        data_type_str: z.ZodString;
+        is_custom_type: z.ZodBoolean;
+        custom_type_type: z.ZodNullable<z.ZodString>;
+        custom_type_category: z.ZodNullable<z.ZodString>;
+        custom_type_schema: z.ZodNullable<z.ZodString>;
+        custom_type_name: z.ZodNullable<z.ZodString>;
+        not_null: z.ZodBoolean;
+        is_identity: z.ZodBoolean;
+        is_identity_always: z.ZodBoolean;
+        is_generated: z.ZodBoolean;
+        collation: z.ZodNullable<z.ZodString>;
+        default: z.ZodNullable<z.ZodString>;
+        comment: 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>;
+type ForeignTablePrivilegeProps = PrivilegeProps;
+export type ForeignTableProps = z.infer<typeof foreignTablePropsSchema>;
+export declare class ForeignTable extends BasePgModel implements TableLikeObject {
+    readonly schema: ForeignTableProps["schema"];
+    readonly name: ForeignTableProps["name"];
+    readonly owner: ForeignTableProps["owner"];
+    readonly server: ForeignTableProps["server"];
+    readonly options: ForeignTableProps["options"];
+    readonly comment: ForeignTableProps["comment"];
+    readonly columns: ForeignTableProps["columns"];
+    readonly privileges: ForeignTablePrivilegeProps[];
+    constructor(props: ForeignTableProps);
+    get stableId(): `foreignTable:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        owner: string;
+        server: string;
+        options: string[] | null;
+        comment: string | null;
+        columns: {
+            name: string;
+            position: number;
+            data_type: string;
+            data_type_str: string;
+            is_custom_type: boolean;
+            custom_type_type: string | null;
+            custom_type_category: string | null;
+            custom_type_schema: string | null;
+            custom_type_name: string | null;
+            not_null: boolean;
+            is_identity: boolean;
+            is_identity_always: boolean;
+            is_generated: boolean;
+            collation: string | null;
+            default: string | null;
+            comment: string | null;
+        }[];
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+    stableSnapshot(): {
+        identity: {
+            schema: string;
+            name: string;
+        };
+        data: {
+            columns: {
+                [x: string]: unknown;
+            }[];
+            owner: string;
+            server: string;
+            options: string[] | null;
+            comment: string | null;
+            privileges: {
+                grantee: string;
+                privilege: string;
+                grantable: boolean;
+                columns?: string[] | null | undefined;
+            }[];
+        };
+    };
+}
+export declare function extractForeignTables(sql: Sql): Promise<ForeignTable[]>;
+export {};

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

@@ -0,0 +1,215 @@
+import z from "zod";
+import { BasePgModel, columnPropsSchema, } from "../../base.model.js";
+import { privilegePropsSchema, } from "../../base.privilege-diff.js";
+/**
+ * All properties exposed by CREATE FOREIGN TABLE statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createforeigntable.html
+ *
+ * ALTER FOREIGN TABLE statement can be generated for changes to the following properties:
+ *  - owner, columns, options
+ * https://www.postgresql.org/docs/17/sql-alterforeigntable.html
+ *
+ * Foreign tables are schema-qualified and similar to regular tables but reference a server.
+ */
+const foreignTablePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    owner: z.string(),
+    server: z.string(),
+    options: z.array(z.string()).nullable(),
+    comment: z.string().nullable(),
+    columns: z.array(columnPropsSchema),
+    privileges: z.array(privilegePropsSchema),
+});
+export class ForeignTable extends BasePgModel {
+    schema;
+    name;
+    owner;
+    server;
+    options;
+    comment;
+    columns;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.owner = props.owner;
+        this.server = props.server;
+        this.options = props.options;
+        this.comment = props.comment;
+        this.columns = props.columns;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `foreignTable:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            owner: this.owner,
+            server: this.server,
+            options: this.options,
+            comment: this.comment,
+            columns: this.columns,
+            privileges: this.privileges,
+        };
+    }
+    stableSnapshot() {
+        const normalizeColumns = () => [...this.columns]
+            .map((col) => {
+            const { position: _pos, ...rest } = col;
+            return rest;
+        })
+            .sort((a, b) => {
+            const nameA = a.name ?? "";
+            const nameB = b.name ?? "";
+            return nameA.localeCompare(nameB);
+        });
+        return {
+            identity: this.identityFields,
+            data: {
+                ...this.dataFields,
+                columns: normalizeColumns(),
+            },
+        };
+    }
+}
+export async function extractForeignTables(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const tableRows = await sql `
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_class'::regclass
+      ), foreign_tables as (
+        select
+          c.relnamespace::regnamespace::text as schema,
+          quote_ident(c.relname) as name,
+          c.relowner::regrole::text as owner,
+          quote_ident(srv.srvname) as server,
+          coalesce(ft.ftoptions, array[]::text[]) as options,
+          c.oid as oid
+        from
+          pg_class c
+          inner join pg_foreign_table ft on ft.ftrelid = c.oid
+          inner join pg_foreign_server srv on srv.oid = ft.ftserver
+          inner join pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+          left outer join extension_oids e1 on c.oid = e1.objid
+        where
+          c.relkind = 'f'
+          and not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+          and e1.objid is null
+          and not fdw.fdwname like any(array['pg\\_%'])
+      )
+      select
+        ft.schema,
+        ft.name,
+        ft.owner,
+        ft.server,
+        ft.options,
+        obj_description(ft.oid, 'pg_class') as comment,
+        coalesce(json_agg(
+          case when a.attname is not null then
+            json_build_object(
+              'name', quote_ident(a.attname),
+              'position', a.attnum,
+              'data_type', a.atttypid::regtype::text,
+              'data_type_str', format_type(a.atttypid, a.atttypmod),
+              'is_custom_type', ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema'),
+              'custom_type_type', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typtype else null end,
+              'custom_type_category', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typcategory else null end,
+              'custom_type_schema', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typnamespace::regnamespace else null end,
+              'custom_type_name', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then quote_ident(ty.typname) else null end,
+              'not_null', a.attnotnull,
+              'is_identity', a.attidentity != '',
+              'is_identity_always', a.attidentity = 'a',
+              'is_generated', a.attgenerated != '',
+              'collation', (
+                select quote_ident(c2.collname)
+                from pg_collation c2, pg_type t2
+                where c2.oid = a.attcollation
+                  and t2.oid = a.atttypid
+                  and a.attcollation <> t2.typcollation
+              ),
+              'default', pg_get_expr(ad.adbin, ad.adrelid),
+              'comment', col_description(a.attrelid, a.attnum)
+            )
+          end
+          order by a.attnum
+        ) filter (where a.attname is not null), '[]') as columns,
+        coalesce((
+          select json_agg(
+                  json_build_object(
+                    'grantee', case when grp.grantee = 0 then 'PUBLIC' else grp.grantee::regrole::text end,
+                    'privilege', grp.privilege_type,
+                    'grantable', grp.is_grantable,
+                    'columns', case when grp.cols is not null and array_length(grp.cols,1) > 0
+                                    then grp.cols
+                                    else null end
+                  )
+                  order by grp.grantee, grp.privilege_type
+                )
+          from (
+            select
+              x.grantee,
+              x.privilege_type,
+              bool_or(x.is_grantable) as is_grantable,
+              array_agg(quote_ident(src.attname) order by src.attname)
+                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, ft.oid as relacl_oid, (
+                select c_rel.relacl from pg_class c_rel where c_rel.oid = ft.oid
+              ) as acl
+              union all
+              select a2.attname, ft.oid as relacl_oid, a2.attacl
+              from pg_attribute a2
+              where a2.attrelid = ft.oid
+                and a2.attnum > 0
+                and not a2.attisdropped
+                and a2.attacl is not null
+            ) as src
+            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
+      from
+        foreign_tables ft
+        left join pg_attribute a on a.attrelid = ft.oid and a.attnum > 0 and not a.attisdropped
+        left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
+        left join pg_type ty on ty.oid = a.atttypid
+      group by
+        ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
+      order by
+        ft.schema, ft.name;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = tableRows.map((row) => {
+            const parsed = foreignTablePropsSchema.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 ForeignTable(row));
+    });
+}

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

@@ -0,0 +1,65 @@
+import type { Server } from "../server.model.ts";
+import { AlterServerChange } from "./server.base.ts";
+/**
+ * Alter a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterserver.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER SERVER name [ VERSION 'new_version' ]
+ *     [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
+ * ALTER SERVER name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ```
+ */
+export type AlterServer = AlterServerChangeOwner | AlterServerSetOptions | AlterServerSetVersion;
+/**
+ * ALTER SERVER ... OWNER TO ...
+ */
+export declare class AlterServerChangeOwner extends AlterServerChange {
+    readonly server: Server;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        server: Server;
+        owner: string;
+    });
+    get requires(): (`role:${string}` | `server:${string}`)[];
+    serialize(): string;
+}
+/**
+ * ALTER SERVER ... VERSION ...
+ */
+export declare class AlterServerSetVersion extends AlterServerChange {
+    readonly server: Server;
+    readonly version: string | null;
+    readonly scope: "object";
+    constructor(props: {
+        server: Server;
+        version: string | null;
+    });
+    get requires(): `server:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER SERVER ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export declare class AlterServerSetOptions extends AlterServerChange {
+    readonly server: Server;
+    readonly options: Array<{
+        action: "ADD" | "SET" | "DROP";
+        option: string;
+        value?: string;
+    }>;
+    readonly scope: "object";
+    constructor(props: {
+        server: Server;
+        options: Array<{
+            action: "ADD" | "SET" | "DROP";
+            option: string;
+            value?: string;
+        }>;
+    });
+    get requires(): `server:${string}`[];
+    serialize(): string;
+}