@supabase/pg-delta 1.0.0-alpha.12 → 1.0.0-alpha.14

package/src/core/connection-url.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "bun:test";
+import { isIPv6, normalizeConnectionUrl } from "./connection-url.ts";
+
+describe("isIPv6", () => {
+  describe("accepted", () => {
+    const accepted = [
+      "::",
+      "::1",
+      "1::",
+      "1:2:3:4:5:6:7:8",
+      "2406:da18:243:740f:abda:9a5c:a92d:b3c9",
+      "::ffff:192.0.2.1",
+      "fe80::AbCd",
+      "fe80::1%eth0",
+    ];
+    for (const value of accepted) {
+      test(`accepts "${value}"`, () => {
+        expect(isIPv6(value)).toBe(true);
+      });
+    }
+  });
+
+  describe("rejected", () => {
+    const rejected = [
+      "",
+      "2406:da18:243:740f", // only 4 groups
+      "1:2:3:4:5:6:7:8:9", // 9 groups
+      "1::2::3", // double compression
+      "gggg::1", // invalid hex
+      "1.2.3.4", // pure IPv4
+      "[::1]", // bracketed
+      "localhost",
+      "example.com",
+      ":::", // malformed
+    ];
+    for (const value of rejected) {
+      test(`rejects ${JSON.stringify(value)}`, () => {
+        expect(isIPv6(value)).toBe(false);
+      });
+    }
+  });
+});
+
+describe("normalizeConnectionUrl", () => {
+  describe("normalizes percent-encoded IPv6 hosts", () => {
+    test("full 8-group IPv6 becomes bracketed", () => {
+      const input =
+        "postgresql://user:pass@2406%3Ada18%3A243%3A740f%3Aabda%3A9a5c%3Aa92d%3Ab3c9:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:pass@[2406:da18:243:740f:abda:9a5c:a92d:b3c9]:5432/db",
+      );
+    });
+
+    test("compressed ::1 form", () => {
+      const input = "postgresql://user:pass@%3A%3A1:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:pass@[::1]:5432/db",
+      );
+    });
+
+    test("IPv4-mapped ::ffff:192.0.2.1", () => {
+      const input = "postgresql://user:pass@%3A%3Affff%3A192.0.2.1:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:pass@[::ffff:192.0.2.1]:5432/db",
+      );
+    });
+
+    test("mixed-case percent triples (%3a and %3A)", () => {
+      const input =
+        "postgresql://user:pass@2406%3ada18%3A243%3a740f%3Aabda%3A9a5c%3Aa92d%3Ab3c9:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:pass@[2406:da18:243:740f:abda:9a5c:a92d:b3c9]:5432/db",
+      );
+    });
+
+    test("preserves URL-encoded password and query string", () => {
+      const input =
+        "postgresql://user:p%40ss%2Fword@%3A%3A1:5432/db?sslmode=require&application_name=pgdelta";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:p%40ss%2Fword@[::1]:5432/db?sslmode=require&application_name=pgdelta",
+      );
+    });
+
+    test("preserves fragment", () => {
+      const input = "postgresql://user:pass@%3A%3A1:5432/db#frag";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:pass@[::1]:5432/db#frag",
+      );
+    });
+
+    test("works without a port", () => {
+      const input = "postgresql://user:pass@%3A%3A1/db";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user:pass@[::1]/db",
+      );
+    });
+
+    test("works without userinfo", () => {
+      const input = "postgresql://%3A%3A1:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe("postgresql://[::1]:5432/db");
+    });
+
+    test("works with username only (no password)", () => {
+      const input = "postgresql://user@%3A%3A1:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(
+        "postgresql://user@[::1]:5432/db",
+      );
+    });
+  });
+
+  describe("leaves URL unchanged (guardrail)", () => {
+    test("already-bracketed IPv6", () => {
+      const input = "postgresql://user:pass@[::1]:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(input);
+    });
+
+    test("IPv4 host", () => {
+      const input = "postgresql://user:pass@127.0.0.1:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(input);
+    });
+
+    test("DNS hostname", () => {
+      const input = "postgresql://user:pass@db.example.com:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(input);
+    });
+
+    test("percent-encoded colons that do not decode to a valid IPv6 (4 groups only)", () => {
+      const input = "postgresql://user:pass@2406%3Ada18%3A243%3A740f:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(input);
+    });
+
+    test("non-colon percent-encoded character in hostname", () => {
+      const input = "postgresql://user:pass@host%2Dname:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(input);
+    });
+
+    test("garbage host `%3A%3Azzz` decodes to `::zzz`, not valid IPv6", () => {
+      const input = "postgresql://user:pass@%3A%3Azzz:5432/db";
+      expect(normalizeConnectionUrl(input)).toBe(input);
+    });
+  });
+});

package/src/core/connection-url.ts

@@ -0,0 +1,82 @@
+/**
+ * Connection URL normalization for pg-delta.
+ *
+ * Auto-normalizes percent-encoded IPv6 hosts in PostgreSQL connection URLs.
+ * A URL like `postgresql://user:pass@2406%3Ada18%3A...%3Ab3c9:5432/db`
+ * becomes `postgresql://user:pass@[2406:da18:...:b3c9]:5432/db` before it
+ * reaches `pg-connection-string` / `pg.Pool`, so DNS resolution sees the
+ * address in its canonical bracketed form.
+ *
+ * Non-IPv6 hosts (IPv4, DNS names, already-bracketed IPv6, partial fragments
+ * that just happen to contain `%3A`) are returned verbatim.
+ */
+
+// IPv6 detection regex vendored from ip-regex (Sindre Sorhus, MIT).
+// https://github.com/sindresorhus/ip-regex
+const v4 =
+  "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+const v6seg = "[a-fA-F\\d]{1,4}";
+const v6 = `
+(?:
+(?:${v6seg}:){7}(?:${v6seg}|:)|
+(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|
+(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)|
+(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)|
+(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)|
+(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)|
+(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)|
+(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))
+)(?:%[0-9a-zA-Z]{1,})?
+`
+  .replace(/\s*\/\/.*$/gm, "")
+  .replace(/\n/g, "")
+  .trim();
+
+const V6_EXACT = new RegExp(`^${v6}$`);
+
+/**
+ * Return true if `value` is a valid IPv6 literal in any canonical form:
+ * full 8-group, `::` compression, or IPv4-mapped (`::ffff:1.2.3.4`).
+ * RFC 4007 zone identifiers (`fe80::1%eth0`) are accepted.
+ */
+export function isIPv6(value: string): boolean {
+  return typeof value === "string" && V6_EXACT.test(value);
+}
+
+/**
+ * Normalize a PostgreSQL connection URL so IPv6 hosts reach pg in the
+ * canonical bracketed form.
+ *
+ * If the URL's hostname contains a percent-encoded colon AND the decoded
+ * hostname is a valid IPv6 literal, the hostname is decoded and wrapped in
+ * `[...]`. All other fields (scheme, userinfo, port, path, query, fragment)
+ * are preserved byte-for-byte from the input.
+ *
+ * Any URL whose decoded hostname does not validate as IPv6 is returned
+ * verbatim, so a malformed input will surface its usual downstream error
+ * instead of being silently rewritten.
+ */
+export function normalizeConnectionUrl(url: string): string {
+  const urlObj = new URL(url);
+  // Cheap pre-filter: only look closer if the hostname contains a
+  // percent-encoded colon. Anything else is left entirely untouched.
+  if (!/%3[aA]/.test(urlObj.hostname)) return url;
+
+  const decodedHost = decodeURIComponent(urlObj.hostname);
+  // Authoritative validation: only normalize when the decoded string is a
+  // real IPv6 literal. Rejects partial fragments, random hostnames that
+  // happen to contain `%3A`, and any malformed input.
+  if (!isIPv6(decodedHost)) return url;
+
+  // Preserve username/password/port/path/search/hash exactly as they appear
+  // in the WHATWG URL model (these are returned already percent-encoded).
+  const scheme = `${urlObj.protocol}//`;
+  const auth = urlObj.username
+    ? urlObj.password
+      ? `${urlObj.username}:${urlObj.password}@`
+      : `${urlObj.username}@`
+    : "";
+  const port = urlObj.port ? `:${urlObj.port}` : "";
+  const tail = `${urlObj.pathname}${urlObj.search}${urlObj.hash}`;
+  return `${scheme}${auth}[${decodedHost}]${port}${tail}`;
+}

package/src/core/export/index.ts

@@ -4,7 +4,11 @@
 
 import type { Change } from "../change.types.ts";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.ts";
-import type { Integration } from "../integrations/integration.types.ts";
+import {
+  type Integration,
+  type ResolvedIntegration,
+  resolveIntegration,
+} from "../integrations/integration.types.ts";
 import type { createPlan } from "../plan/create.ts";
 import { DEFAULT_OPTIONS } from "../plan/sql-format/constants.ts";
 import type { SqlFormatOptions } from "../plan/sql-format/types.ts";
@@ -29,7 +33,7 @@ type PlanResult = NonNullable<Awaited<ReturnType<typeof createPlan>>>;
 
 export interface ExportOptions {
   /** Integration for custom serialization */
-  integration?: Integration;
+  integration?: Pick<Integration, "serialize">;
   /**
    * SQL formatter options to control the output style.
    * Merged on top of the default export options (maxWidth: 180, keywordCase: "upper").
@@ -64,7 +68,9 @@ export function exportDeclarativeSchema(
   options?: ExportOptions,
 ): DeclarativeSchemaOutput {
   const { ctx, sortedChanges } = planResult;
-  const integration = options?.integration;
+  const integration = options?.integration
+    ? resolveIntegration(options?.integration)
+    : {};
   const formatOptions: SqlFormatOptions | undefined =
     options?.formatOptions === null
       ? undefined
@@ -108,7 +114,10 @@ export function exportDeclarativeSchema(
   };
 }
 
-function serializeChange(change: Change, integration?: Integration): string {
+function serializeChange(
+  change: Change,
+  integration?: ResolvedIntegration,
+): string {
   return integration?.serialize?.(change) ?? change.serialize();
 }
 

package/src/core/integrations/integration.types.ts

@@ -1,7 +1,65 @@
+import { compileFilterDSL, type FilterDSL } from "./filter/dsl.ts";
 import type { ChangeFilter } from "./filter/filter.types.ts";
+import { compileSerializeDSL, type SerializeDSL } from "./serialize/dsl.ts";
 import type { ChangeSerializer } from "./serialize/serialize.types.ts";
 
-export type Integration = {
+/**
+ * A resolved integration is an integration that has been compiled to a function.
+ */
+export type ResolvedIntegration = {
   filter?: ChangeFilter;
   serialize?: ChangeSerializer;
 };
+
+/**
+ * A raw integration is an integration that has not been compiled to a function.
+ */
+export type IntegrationDSL = {
+  filter?: FilterDSL;
+  serialize?: SerializeDSL;
+};
+
+/**
+ * An integration is a raw integration that has not been compiled to a function.
+ */
+export type Integration = {
+  filter?: ResolvedIntegration["filter"] | IntegrationDSL["filter"];
+  serialize?: ResolvedIntegration["serialize"] | IntegrationDSL["serialize"];
+};
+
+/**
+ * Resolve an integration either DSL or already resovled into a ResolvedIntegration.
+ * @param integration - The integration to resolve.
+ * @returns The resolved integration.
+ */
+export function resolveIntegration(
+  integration: Integration,
+): ResolvedIntegration | undefined {
+  // Determine if filter/serialize are DSL or functions, and extract DSL for storage
+  const isFilterDSL =
+    integration.filter && typeof integration.filter !== "function";
+  const isSerializeDSL =
+    integration.serialize && typeof integration.serialize !== "function";
+  const filterDSL = isFilterDSL ? (integration.filter as FilterDSL) : undefined;
+  const serializeDSL = isSerializeDSL
+    ? (integration.serialize as SerializeDSL)
+    : undefined;
+
+  // Build final integration: compile DSL if needed, use functions directly otherwise
+  if (integration.filter || integration.serialize) {
+    return {
+      filter:
+        typeof integration.filter === "function"
+          ? integration.filter
+          : filterDSL
+            ? compileFilterDSL(filterDSL)
+            : undefined,
+      serialize:
+        typeof integration.serialize === "function"
+          ? integration.serialize
+          : serializeDSL
+            ? compileSerializeDSL(serializeDSL)
+            : undefined,
+    };
+  }
+}

package/src/core/integrations/supabase.ts

@@ -16,6 +16,7 @@ const SUPABASE_SYSTEM_SCHEMAS = [
   "_supavisor",
   "auth",
   "cron",
+  "etl",
   "extensions",
   "graphql",
   "graphql_public",

package/src/core/objects/procedure/procedure.diff.test.ts

@@ -9,6 +9,7 @@ import {
   AlterProcedureSetStrictness,
   AlterProcedureSetVolatility,
 } from "./changes/procedure.alter.ts";
+import { CreateCommentOnProcedure } from "./changes/procedure.comment.ts";
 import { CreateProcedure } from "./changes/procedure.create.ts";
 import { DropProcedure } from "./changes/procedure.drop.ts";
 import { diffProcedures } from "./procedure.diff.ts";
@@ -158,4 +159,28 @@ describe.concurrent("procedure.diff", () => {
     expect(changes).toHaveLength(1);
     expect(changes[0]).toBeInstanceOf(CreateProcedure);
   });
+
+  test("create or replace also emits a procedure comment when the comment changes", () => {
+    const main = new Procedure(base);
+    const branch = new Procedure({
+      ...base,
+      definition:
+        "CREATE FUNCTION public.fn1() RETURNS int4 LANGUAGE sql AS $$SELECT 42::int4$$",
+      source_code: "SELECT 42::int4",
+      comment: "updated comment",
+    });
+
+    const changes = diffProcedures(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    expect(changes.some((change) => change instanceof CreateProcedure)).toBe(
+      true,
+    );
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnProcedure),
+    ).toBe(true);
+  });
 });

package/src/core/objects/procedure/procedure.diff.ts

@@ -169,6 +169,18 @@ export function diffProcedures(
       changes.push(
         new CreateProcedure({ procedure: branchProcedure, orReplace: true }),
       );
+
+      if (mainProcedure.comment !== branchProcedure.comment) {
+        if (branchProcedure.comment === null) {
+          changes.push(
+            new DropCommentOnProcedure({ procedure: mainProcedure }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnProcedure({ procedure: branchProcedure }),
+          );
+        }
+      }
     } else {
       // Only alterable properties changed - check each one
 

package/src/core/objects/table/changes/table.alter.test.ts

@@ -492,6 +492,20 @@ describe.concurrent("table", () => {
         "ALTER TABLE public.test_table ALTER COLUMN a SET DEFAULT 0",
       );
 
+      const changeSetGeneratedExpression = new AlterTableAlterColumnSetDefault({
+        table: withCols,
+        column: {
+          ...colText,
+          name: "computed_name",
+          is_generated: true,
+          default: "lower((b))",
+        },
+      });
+      await assertValidSql(changeSetGeneratedExpression.serialize());
+      expect(changeSetGeneratedExpression.serialize()).toBe(
+        "ALTER TABLE public.test_table ALTER COLUMN computed_name SET EXPRESSION AS (lower((b)))",
+      );
+
       const changeDropDefault = new AlterTableAlterColumnDropDefault({
         table: withCols,
         column: { ...colInt, default: null },

package/src/core/objects/table/changes/table.alter.ts

@@ -644,6 +644,9 @@ export class AlterTableAlterColumnSetDefault extends AlterTableChange {
 
   serialize(_options?: SerializeOptions): string {
     const set = this.column.is_generated ? "SET EXPRESSION AS" : "SET DEFAULT";
+    const value = this.column.is_generated
+      ? `(${this.column.default ?? "NULL"})`
+      : (this.column.default ?? "NULL");
 
     return [
       "ALTER TABLE",
@@ -651,7 +654,7 @@ export class AlterTableAlterColumnSetDefault extends AlterTableChange {
       "ALTER COLUMN",
       this.column.name,
       set,
-      this.column.default ?? "NULL",
+      value,
     ].join(" ");
   }
 }

package/src/core/objects/table/table.diff.test.ts

@@ -835,6 +835,61 @@ describe.concurrent("table.diff", () => {
     ).toBe(true);
   });
 
+  test("postgres 17+ recreates a column when switching from regular to generated", () => {
+    const pg17Context = {
+      ...testContext,
+      version: 170000,
+    };
+
+    const regularColumn = {
+      name: "confirmed_at",
+      position: 1,
+      data_type: "timestamp with time zone",
+      data_type_str: "timestamp with time zone",
+      is_custom_type: false,
+      custom_type_type: null,
+      custom_type_category: null,
+      custom_type_schema: null,
+      custom_type_name: null,
+      not_null: false,
+      is_identity: false,
+      is_identity_always: false,
+      is_generated: false,
+      collation: null,
+      default: null,
+      comment: null,
+    };
+
+    const generatedColumn = {
+      ...regularColumn,
+      is_generated: true,
+      default: "LEAST(email_confirmed_at, phone_confirmed_at)",
+    };
+
+    const mainTable = new Table({
+      ...base,
+      name: "auth_users_like",
+      columns: [regularColumn],
+    });
+    const branchTable = new Table({
+      ...base,
+      name: "auth_users_like",
+      columns: [generatedColumn],
+    });
+
+    const changes = diffTables(
+      pg17Context,
+      { [mainTable.stableId]: mainTable },
+      { [branchTable.stableId]: branchTable },
+    );
+
+    expect(changes.some((c) => c instanceof AlterTableDropColumn)).toBe(true);
+    expect(changes.some((c) => c instanceof AlterTableAddColumn)).toBe(true);
+    expect(
+      changes.some((c) => c instanceof AlterTableAlterColumnSetDefault),
+    ).toBe(false);
+  });
+
   test("created table with privileges emits grant changes", () => {
     const t = new Table({
       ...base,

package/src/core/objects/table/table.diff.ts

@@ -745,10 +745,18 @@ export function diffTables(
             // Set new default value
             const isGeneratedColumn = branchCol.is_generated;
             const isPostgresLowerThan17 = ctx.version < 170000;
+            const generatedStatusChanged =
+              mainCol.is_generated !== branchCol.is_generated;
 
-            if (isGeneratedColumn && isPostgresLowerThan17) {
+            if (
+              isGeneratedColumn &&
+              (isPostgresLowerThan17 || generatedStatusChanged)
+            ) {
               // For generated columns in < PostgreSQL 17, we need to drop and recreate
-              // instead of using SET EXPRESSION AS for computed columns
+              // instead of using SET EXPRESSION AS for computed columns. We also
+              // need to recreate the column when switching between regular and
+              // generated states because SET EXPRESSION only applies to existing
+              // generated columns.
               // cf: https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=5d06e99a3
               // cf: https://www.postgresql.org/docs/release/17.0/
               // > Allow ALTER TABLE to change a column's generation expression

package/src/core/plan/create.ts

@@ -10,15 +10,12 @@ import { createEmptyCatalog, extractCatalog } from "../catalog.model.ts";
 import type { Change } from "../change.types.ts";
 import type { DiffContext } from "../context.ts";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.ts";
+import type { FilterDSL } from "../integrations/filter/dsl.ts";
 import {
-  compileFilterDSL,
-  type FilterDSL,
-} from "../integrations/filter/dsl.ts";
-import type { Integration } from "../integrations/integration.types.ts";
-import {
-  compileSerializeDSL,
-  type SerializeDSL,
-} from "../integrations/serialize/dsl.ts";
+  type ResolvedIntegration,
+  resolveIntegration,
+} from "../integrations/integration.types.ts";
+import type { SerializeDSL } from "../integrations/serialize/dsl.ts";
 import { createManagedPool, endPool } from "../postgres-config.ts";
 import { sortChanges } from "../sort/sort-changes.ts";
 import type { PgDependRow } from "../sort/types.ts";
@@ -155,23 +152,10 @@ function buildPlanForCatalogs(
     : undefined;
 
   // Build final integration: compile DSL if needed, use functions directly otherwise
-  let finalIntegration: Integration | undefined;
-  if (filterOption || serializeOption) {
-    finalIntegration = {
-      filter:
-        typeof filterOption === "function"
-          ? filterOption
-          : filterDSL
-            ? compileFilterDSL(filterDSL)
-            : undefined,
-      serialize:
-        typeof serializeOption === "function"
-          ? serializeOption
-          : serializeDSL
-            ? compileSerializeDSL(serializeDSL)
-            : undefined,
-    };
-  }
+  const finalIntegration = resolveIntegration({
+    filter: filterOption,
+    serialize: serializeOption,
+  });
 
   // Use filter from final integration
   const filterFn = finalIntegration?.filter;
@@ -317,7 +301,7 @@ function buildPlan(
   options?: CreatePlanOptions,
   filterDSL?: FilterDSL,
   serializeDSL?: SerializeDSL,
-  integration?: Integration,
+  integration?: ResolvedIntegration,
 ): Plan {
   const role = options?.role;
   const statements = generateStatements(changes, {
@@ -350,7 +334,7 @@ function buildPlan(
 function generateStatements(
   changes: Change[],
   options?: {
-    integration?: Integration;
+    integration?: ResolvedIntegration;
     role?: string;
   },
 ): string[] {

package/src/core/plan/types.ts

@@ -4,10 +4,7 @@
 
 import z from "zod";
 import type { Change } from "../change.types.ts";
-import type { FilterDSL } from "../integrations/filter/dsl.ts";
-import type { ChangeFilter } from "../integrations/filter/filter.types.ts";
-import type { SerializeDSL } from "../integrations/serialize/dsl.ts";
-import type { ChangeSerializer } from "../integrations/serialize/serialize.types.ts";
+import type { Integration } from "../integrations/integration.types.ts";
 
 // ============================================================================
 // Core Types
@@ -157,9 +154,9 @@ export type Plan = z.infer<typeof PlanSchema>;
  */
 export interface CreatePlanOptions {
   /** Filter - either FilterDSL (stored in plan) or ChangeFilter function (not stored) */
-  filter?: FilterDSL | ChangeFilter;
+  filter?: Integration["filter"];
   /** Serialize - either SerializeDSL (stored in plan) or ChangeSerializer function (not stored) */
-  serialize?: SerializeDSL | ChangeSerializer;
+  serialize?: Integration["serialize"];
   /** Role to use when executing the migration (SET ROLE will be added to statements) */
   role?: string;
   /**