@aoxborrow/registrar-client 0.9.2 → 0.10.1

package/dist/index.d.cts

@@ -178,10 +178,12 @@ interface EmailForward {
     forwardTo: string;
 }
 type DomainForwardType = 'temporary' | 'permanent' | 'masked';
+type DomainForwardHttps = 'off' | 'on' | 'only';
 interface DomainForward {
     host: string;
     url: string;
     type: DomainForwardType;
+    https?: DomainForwardHttps;
 }
 interface DsRecord {
     keyTag: number;
@@ -575,6 +577,7 @@ declare class GandiRegistrar extends BaseRegistrar {
     setEmailForwarding(domainName: string, forwards: EmailForward[], opts?: RequestOptions): Promise<OperationResult>;
     getDomainForwarding(domainName: string, opts?: RequestOptions): Promise<DomainForward[]>;
     setDomainForwarding(domainName: string, forwards: DomainForward[], opts?: RequestOptions): Promise<OperationResult>;
+    private listWebredirs;
     setAutoRenew(domainName: string, enabled: boolean, opts?: RequestOptions): Promise<OperationResult>;
     setPrivacy(domainName: string, enabled: boolean, opts?: RequestOptions): Promise<OperationResult>;
     setDnsRecords(domainName: string, records: DnsRecord[], opts?: RequestOptions): Promise<OperationResult>;
@@ -916,7 +919,8 @@ type SettableDomainForward = DomainForward & {
     type: 'temporary' | 'permanent';
 };
 declare const MASKED_FORWARD_UNSUPPORTED = "masked/framed forwarding is not supported by this library; use \"temporary\" or \"permanent\"";
-declare function settableForwards(forwards: DomainForward[]): SettableDomainForward[];
+declare function settableForwards(forwards: DomainForward[], httpsModes?: readonly DomainForwardHttps[]): SettableDomainForward[];
+declare function unsupportedForwardHttps(mode: DomainForwardHttps, httpsModes?: readonly DomainForwardHttps[]): string;
 declare function requireConsent(provider: string, consent: RegistrationConsent | undefined): RegistrationConsent;
 declare function filterDomains(domains: Domain[], search?: string): Domain[];
 declare function normalizeDomain(domain: string): string;
@@ -926,4 +930,5 @@ declare function normalizeNameservers(nameservers: unknown): string[];
 declare function createDomain(data?: DomainInput): Domain;
 declare function asRead<T extends RequestOptions>(opts?: T): T;
 
-export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, type ConfigField, ConfigurationError, ConnectionError, type ConnectionResult, ConsentRequiredError, type Contact, type ContactSet, DEFAULT_OPTIONS, type DelegationSigner, type DnsEntry, type DnsRecord, DnsSyntaxError, type DnssecStatus, type Domain, Domain101Registrar, type DomainAvailability, type DomainForward, type DomainForwardType, type DomainInput, type DomainSource, type DsRecord, DynadotRegistrar, EXTENDED_FEATURES, type EmailForward, FEATURE_CALLS, Feature, type FeatureCall, GandiRegistrar, GoDaddyRegistrar, HttpClient, type HttpClientConfig, InvalidResponseError, type LabelMapper, type ListDomainsOptions, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, type NameRole, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, type OperationResult, OutcomeUnknownError, ParsingError, PorkbunRegistrar, type PortfolioError, type PortfolioResult, REST_SAFE_METHODS, RateLimitError, type RecordClash, type RegisterDomainInput, type Registrar, RegistrarClient, type RegistrarClientOptions, type RegistrarConstructor, type RegistrarCredentials, type RegistrarEnvironment, RegistrarError, type RegistrarFeature, type RegistrarName, type RegistrarOptions, type RegistrationConsent, type RequestConfig, type RequestIntent, type RequestOptions, RetryableRegistrarError, type SettableDomainForward, SpaceshipRegistrar, TimeoutError, type TldPricing, type TransferDomainInput, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, useLabelMapper, wasNotSent };
+export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DnsSyntaxError, Domain101Registrar, DynadotRegistrar, EXTENDED_FEATURES, FEATURE_CALLS, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, OutcomeUnknownError, ParsingError, PorkbunRegistrar, REST_SAFE_METHODS, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, unsupportedForwardHttps, useLabelMapper, wasNotSent };
+export type { ConfigField, ConnectionResult, Contact, ContactSet, DelegationSigner, DnsEntry, DnsRecord, DnssecStatus, Domain, DomainAvailability, DomainForward, DomainForwardHttps, DomainForwardType, DomainInput, DomainSource, DsRecord, EmailForward, FeatureCall, HttpClientConfig, LabelMapper, ListDomainsOptions, NameRole, OperationResult, PortfolioError, PortfolioResult, RecordClash, RegisterDomainInput, Registrar, RegistrarClientOptions, RegistrarConstructor, RegistrarCredentials, RegistrarEnvironment, RegistrarFeature, RegistrarName, RegistrarOptions, RegistrationConsent, RequestConfig, RequestIntent, RequestOptions, SettableDomainForward, TldPricing, TransferDomainInput };

package/dist/index.d.ts

@@ -178,10 +178,12 @@ interface EmailForward {
     forwardTo: string;
 }
 type DomainForwardType = 'temporary' | 'permanent' | 'masked';
+type DomainForwardHttps = 'off' | 'on' | 'only';
 interface DomainForward {
     host: string;
     url: string;
     type: DomainForwardType;
+    https?: DomainForwardHttps;
 }
 interface DsRecord {
     keyTag: number;
@@ -575,6 +577,7 @@ declare class GandiRegistrar extends BaseRegistrar {
     setEmailForwarding(domainName: string, forwards: EmailForward[], opts?: RequestOptions): Promise<OperationResult>;
     getDomainForwarding(domainName: string, opts?: RequestOptions): Promise<DomainForward[]>;
     setDomainForwarding(domainName: string, forwards: DomainForward[], opts?: RequestOptions): Promise<OperationResult>;
+    private listWebredirs;
     setAutoRenew(domainName: string, enabled: boolean, opts?: RequestOptions): Promise<OperationResult>;
     setPrivacy(domainName: string, enabled: boolean, opts?: RequestOptions): Promise<OperationResult>;
     setDnsRecords(domainName: string, records: DnsRecord[], opts?: RequestOptions): Promise<OperationResult>;
@@ -916,7 +919,8 @@ type SettableDomainForward = DomainForward & {
     type: 'temporary' | 'permanent';
 };
 declare const MASKED_FORWARD_UNSUPPORTED = "masked/framed forwarding is not supported by this library; use \"temporary\" or \"permanent\"";
-declare function settableForwards(forwards: DomainForward[]): SettableDomainForward[];
+declare function settableForwards(forwards: DomainForward[], httpsModes?: readonly DomainForwardHttps[]): SettableDomainForward[];
+declare function unsupportedForwardHttps(mode: DomainForwardHttps, httpsModes?: readonly DomainForwardHttps[]): string;
 declare function requireConsent(provider: string, consent: RegistrationConsent | undefined): RegistrationConsent;
 declare function filterDomains(domains: Domain[], search?: string): Domain[];
 declare function normalizeDomain(domain: string): string;
@@ -926,4 +930,5 @@ declare function normalizeNameservers(nameservers: unknown): string[];
 declare function createDomain(data?: DomainInput): Domain;
 declare function asRead<T extends RequestOptions>(opts?: T): T;
 
-export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, type ConfigField, ConfigurationError, ConnectionError, type ConnectionResult, ConsentRequiredError, type Contact, type ContactSet, DEFAULT_OPTIONS, type DelegationSigner, type DnsEntry, type DnsRecord, DnsSyntaxError, type DnssecStatus, type Domain, Domain101Registrar, type DomainAvailability, type DomainForward, type DomainForwardType, type DomainInput, type DomainSource, type DsRecord, DynadotRegistrar, EXTENDED_FEATURES, type EmailForward, FEATURE_CALLS, Feature, type FeatureCall, GandiRegistrar, GoDaddyRegistrar, HttpClient, type HttpClientConfig, InvalidResponseError, type LabelMapper, type ListDomainsOptions, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, type NameRole, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, type OperationResult, OutcomeUnknownError, ParsingError, PorkbunRegistrar, type PortfolioError, type PortfolioResult, REST_SAFE_METHODS, RateLimitError, type RecordClash, type RegisterDomainInput, type Registrar, RegistrarClient, type RegistrarClientOptions, type RegistrarConstructor, type RegistrarCredentials, type RegistrarEnvironment, RegistrarError, type RegistrarFeature, type RegistrarName, type RegistrarOptions, type RegistrationConsent, type RequestConfig, type RequestIntent, type RequestOptions, RetryableRegistrarError, type SettableDomainForward, SpaceshipRegistrar, TimeoutError, type TldPricing, type TransferDomainInput, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, useLabelMapper, wasNotSent };
+export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DnsSyntaxError, Domain101Registrar, DynadotRegistrar, EXTENDED_FEATURES, FEATURE_CALLS, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, OutcomeUnknownError, ParsingError, PorkbunRegistrar, REST_SAFE_METHODS, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, unsupportedForwardHttps, useLabelMapper, wasNotSent };
+export type { ConfigField, ConnectionResult, Contact, ContactSet, DelegationSigner, DnsEntry, DnsRecord, DnssecStatus, Domain, DomainAvailability, DomainForward, DomainForwardHttps, DomainForwardType, DomainInput, DomainSource, DsRecord, EmailForward, FeatureCall, HttpClientConfig, LabelMapper, ListDomainsOptions, NameRole, OperationResult, PortfolioError, PortfolioResult, RecordClash, RegisterDomainInput, Registrar, RegistrarClientOptions, RegistrarConstructor, RegistrarCredentials, RegistrarEnvironment, RegistrarFeature, RegistrarName, RegistrarOptions, RegistrationConsent, RequestConfig, RequestIntent, RequestOptions, SettableDomainForward, TldPricing, TransferDomainInput };

package/dist/index.js

@@ -202,12 +202,18 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 var MASKED_FORWARD_UNSUPPORTED = 'masked/framed forwarding is not supported by this library; use "temporary" or "permanent"';
-function settableForwards(forwards) {
+function settableForwards(forwards, httpsModes = []) {
   for (const f of forwards) {
     if (f.type === "masked") throw new Error(MASKED_FORWARD_UNSUPPORTED);
+    if (f.https !== void 0 && !httpsModes.includes(f.https)) {
+      throw new Error(unsupportedForwardHttps(f.https, httpsModes));
+    }
   }
   return forwards;
 }
+function unsupportedForwardHttps(mode, httpsModes = []) {
+  return `forwarding https "${mode}" can't be set on this provider` + (httpsModes.length ? ` (supported: ${httpsModes.map((m) => `"${m}"`).join(", ")})` : "; leave `https` unset to use its default");
+}
 function requireConsent(provider, consent) {
   if (!consent) {
     throw new ConsentRequiredError(
@@ -1268,7 +1274,7 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
    */
   async setDomainForwarding(domainName, forwards, opts) {
     try {
-      const settable = settableForwards(forwards);
+      const settable = settableForwards(forwards, ["on"]);
       const zone = await this.requireZone(domainName, opts);
       const existing = await this.getRedirectRuleset(zone.id, opts);
       if (settable.length === 0) {
@@ -2126,6 +2132,8 @@ var Domain101Registrar = class extends BaseRegistrar {
       throw new ConfigurationError(
         "101domain: only one permanent apex forwarding rule is supported"
       );
+    if (forwards[0]?.https !== void 0)
+      throw new ConfigurationError(`101domain: ${unsupportedForwardHttps(forwards[0].https)}`);
     if (forwards.length) {
       let url;
       try {
@@ -2644,13 +2652,17 @@ ${bodyStr}`;
     );
   }
   // Auto-renew via the renew_option endpoint. The accepted write values are
-  // "auto" (auto-renew), "donot" (do not renew), and "reset" (manual renewal) —
-  // note these differ from the read values ("auto-renew" etc.).
+  // "auto" (auto-renew), "donot" (do not renew), and "reset" (manual renewal);
+  // they read back as "auto-renew", "do not renew", and "manual renewal". Off
+  // writes "reset": off means "won't renew automatically", and "donot" would
+  // also stop Dynadot's expiration reminder emails, so this never writes it.
+  // "reset" is always manual renewal, even when the account's default renew
+  // option is auto (sandbox-verified 2026-10-28).
   async setAutoRenew(domainName, enabled, opts) {
     return this.mutate(
       "PUT",
       `/restful/v2/domains/${encodeURIComponent(domainName)}/renew_option`,
-      { renew_option: enabled ? "auto" : "donot" },
+      { renew_option: enabled ? "auto" : "reset" },
       `Auto-renew ${enabled ? "enabled" : "disabled"} successfully`,
       opts
     );
@@ -3066,6 +3078,16 @@ var GANDI_TYPE_TO_FORWARD = {
   cloak: "masked"
   // read-only; setDomainForwarding rejects it
 };
+var GANDI_PROTOCOL = {
+  off: "http",
+  on: "https",
+  only: "httpsonly"
+};
+var GANDI_PROTOCOL_TO_HTTPS = {
+  http: "off",
+  https: "on",
+  httpsonly: "only"
+};
 var GandiRegistrar = class extends BaseRegistrar {
   name = "gandi";
   // a REST API: GET and HEAD never change state
@@ -3080,7 +3102,7 @@ var GandiRegistrar = class extends BaseRegistrar {
   static supportsSandbox = true;
   // On top of core: transfer-out auth code (`authinfo`), DNSSEC read/disable
   // (LiveDNS keys), email forwarding, and web/URL forwarding (webredirs;
-  // per-subdomain, no apex). Note core `setPrivacy` disabling is a no-op for
+  // per host, apex included). Note core `setPrivacy` disabling is a no-op for
   // individual (natural-person) registrants — Gandi keeps WHOIS obfuscation on
   // for GDPR regardless of the request.
   static extendedFeatures = [
@@ -3450,73 +3472,128 @@ var GandiRegistrar = class extends BaseRegistrar {
   }
   /**
    * Read web/URL forwarding via GET /domain/domains/{fqdn}/webredirs. Gandi keys
-   * each redirect by the full FQDN of the source subdomain; we normalize that back
-   * to a host relative to the apex (e.g. `shop.example.com` -> `shop`).
+   * each redirect by the full FQDN of the source host; we normalize that back to
+   * a host relative to the apex (e.g. `shop.example.com` -> `shop`, and the bare
+   * domain -> `@`).
    */
   async getDomainForwarding(domainName, opts) {
-    const redirs = await this.http.request({
-      path: `/domain/domains/${domainName}/webredirs`,
-      ...opts
-    });
-    return (redirs ?? []).map((r) => ({
-      host: gandiFqdnToHost(r.host ?? domainName, domainName),
-      url: r.url ?? "",
-      type: GANDI_TYPE_TO_FORWARD[(r.type ?? "").toLowerCase()] ?? "permanent"
-    }));
+    const redirs = await this.listWebredirs(domainName, opts);
+    return redirs.map((r) => fromGandiWebredir(r, domainName));
   }
   /**
-   * Replace web/URL forwarding (full replace; empty clears). Gandi's webredirs
-   * endpoint has no update — only create (POST) and delete (DELETE by FQDN) — so
-   * this diffs against the current set: delete entries that are gone or changed,
-   * then create the desired ones that aren't already present identically.
+   * Replace web/URL forwarding (full replace; empty clears). Diffs against the
+   * current webredirs by host:
+   * - a host that's new is created (POST),
+   * - a host whose url/type/https changed is updated in place (PATCH); with
+   *   `https` unset it keeps the rule's existing `protocol`, so an https
+   *   forward stays https,
+   * - a host that's no longer wanted is deleted (DELETE),
+   * - an identical rule (apex included) is left untouched.
+   * Creates and updates run before any delete, so a failure part-way never leaves
+   * a host that was meant to keep forwarding without a rule. A failure after some
+   * writes landed is reported as a partial update listing what was applied.
+   *
+   * The apex (`@`) is the bare domain FQDN. Creating a redirect needs Gandi's own
+   * DNS record at the source host, and the apex nearly always has one already
+   * (POST then fails with an opaque 500), so creates send `override: true` to
+   * let Gandi replace the host's record — forwarding the host is the point.
    *
-   * Gandi only supports forwarding a subdomain, not the apex; an apex host ("@")
-   * throws rather than silently failing with a 500 from the API.
+   * `https` maps to Gandi's `protocol` (off=http, on=https, only=httpsonly).
+   * A new rule with `https` unset omits `protocol`, so Gandi applies its
+   * default (http). Asking for https makes Gandi provision a Let's Encrypt
+   * certificate for the source host; production does this, but the sandbox
+   * can't (it 500s). Gandi repoints the host at its https redirector at once,
+   * and that refuses the host until the certificate exists, so switching a
+   * live rule to https can leave it unreachable for a while (see gandi.md).
    */
   async setDomainForwarding(domainName, forwards, opts) {
+    const applied = [];
     try {
-      const settable = settableForwards(forwards);
+      const settable = settableForwards(forwards, ["off", "on", "only"]);
+      const desired = /* @__PURE__ */ new Map();
       for (const f of settable) {
-        if (!f.host || f.host === "@") {
-          throw new Error(
-            `${this.name}: web forwarding requires a subdomain host; Gandi cannot forward the apex ("@")`
-          );
+        const host = normalizeForwardHost(f.host);
+        if (desired.has(host)) {
+          throw new Error(`${this.name}: duplicate web forwarding host "${host}"`);
         }
+        desired.set(host, { ...f, host });
       }
-      const current = await this.getDomainForwarding(domainName, opts);
-      const same = (a, b) => a.host === b.host && a.url === b.url && a.type === b.type;
-      for (const existing of current) {
-        if (!settable.some((f) => same(f, existing))) {
-          await this.http.request({
-            method: "DELETE",
-            path: `/domain/domains/${domainName}/webredirs/${gandiHostToFqdn(existing.host, domainName)}`,
-            ...opts
+      const current = /* @__PURE__ */ new Map();
+      for (const r of await this.listWebredirs(domainName, opts)) {
+        current.set(gandiFqdnToHost(r.host ?? domainName, domainName), r);
+      }
+      const writes = [];
+      const webredirPath = (host) => `/domain/domains/${domainName}/webredirs/${gandiHostToFqdn(host, domainName)}`;
+      for (const [host, f] of desired) {
+        const existing = current.get(host);
+        if (!existing) {
+          writes.push({
+            label: `create ${host}`,
+            run: () => this.http.request({
+              method: "POST",
+              path: `/domain/domains/${domainName}/webredirs`,
+              body: {
+                host: gandiHostToFqdn(host, domainName),
+                type: GANDI_FORWARD_TYPE[f.type],
+                url: f.url,
+                ...f.https ? { protocol: GANDI_PROTOCOL[f.https] } : {},
+                override: true
+              },
+              ...opts
+            })
           });
+          continue;
         }
-      }
-      for (const f of settable) {
-        if (!current.some((c) => same(c, f))) {
-          await this.http.request({
-            method: "POST",
-            path: `/domain/domains/${domainName}/webredirs`,
-            // `protocol` is intentionally omitted so Gandi applies its default
-            // (http). Requesting `https` makes Gandi provision a Let's Encrypt
-            // certificate for the source host, which our normalized model doesn't
-            // express (and which the sandbox can't do — it 500s).
+        const now = fromGandiWebredir(existing, domainName);
+        const httpsSame = f.https === void 0 || f.https === now.https;
+        if (now.url === f.url && now.type === f.type && httpsSame) continue;
+        const protocol = f.https ? GANDI_PROTOCOL[f.https] : existing.protocol;
+        writes.push({
+          label: `update ${host}`,
+          run: () => this.http.request({
+            method: "PATCH",
+            path: webredirPath(host),
             body: {
-              host: gandiHostToFqdn(f.host, domainName),
               type: GANDI_FORWARD_TYPE[f.type],
-              url: f.url
+              url: f.url,
+              ...protocol ? { protocol } : {}
             },
             ...opts
-          });
+          })
+        });
+      }
+      for (const host of current.keys()) {
+        if (desired.has(host)) continue;
+        writes.push({
+          label: `delete ${host}`,
+          run: () => this.http.request({ method: "DELETE", path: webredirPath(host), ...opts })
+        });
+      }
+      for (const w of writes) {
+        try {
+          await w.run();
+        } catch (error) {
+          if (applied.length === 0) throw error;
+          const rest = writes.slice(applied.length + 1).map((x) => x.label);
+          return {
+            success: false,
+            message: `Domain forwarding partially updated: ${w.label} failed (${toRegistrarError(error).message}); applied: ${applied.join(", ")}` + (rest.length ? `; not attempted: ${rest.join(", ")}` : "")
+          };
         }
+        applied.push(w.label);
       }
       return { success: true, message: "Domain forwarding updated successfully" };
     } catch (error) {
       return { success: false, message: toRegistrarError(error).message };
     }
   }
+  async listWebredirs(domainName, opts) {
+    const redirs = await this.http.request({
+      path: `/domain/domains/${domainName}/webredirs`,
+      ...opts
+    });
+    return redirs ?? [];
+  }
   async setAutoRenew(domainName, enabled, opts) {
     try {
       await this.http.request({
@@ -3704,6 +3781,18 @@ function gandiFqdnToHost(fqdn, domain) {
   const suffix = `.${domain}`;
   return fqdn.endsWith(suffix) ? fqdn.slice(0, -suffix.length) : fqdn;
 }
+function normalizeForwardHost(host) {
+  return host ? host : "@";
+}
+function fromGandiWebredir(r, domain) {
+  const https = GANDI_PROTOCOL_TO_HTTPS[(r.protocol ?? "").toLowerCase()];
+  return {
+    host: gandiFqdnToHost(r.host ?? domain, domain),
+    url: r.url ?? "",
+    type: GANDI_TYPE_TO_FORWARD[(r.type ?? "").toLowerCase()] ?? "permanent",
+    ...https ? { https } : {}
+  };
+}
 function fromGandiContact(c) {
   if (!c) return void 0;
   return {
@@ -8416,6 +8505,6 @@ function toDnsEntry(record, defaultTtl = 3600) {
   };
 }
 
-export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DnsSyntaxError, Domain101Registrar, DynadotRegistrar, EXTENDED_FEATURES, FEATURE_CALLS, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, OutcomeUnknownError, ParsingError, PorkbunRegistrar, REST_SAFE_METHODS, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, useLabelMapper, wasNotSent };
+export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DnsSyntaxError, Domain101Registrar, DynadotRegistrar, EXTENDED_FEATURES, FEATURE_CALLS, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NamecomRegistrar, NotFoundError, NotImplementedError, OutcomeUnknownError, ParsingError, PorkbunRegistrar, REST_SAFE_METHODS, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, asRead, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, findCnameConflicts, findRepeatedRecords, isCoreFeature, isIpv4, isIpv6, listPortfolio, markNotSent, normalizeDomain, normalizeNameservers, parseDate, parseXml, prepareEntry, prepareName, prepareRdata, readDelegationSigner, registrars, requireConsent, resetLabelMapper, selectBaseUrl, settableForwards, sleep, toDnsEntry, toRegistrarError, unsupportedForwardHttps, useLabelMapper, wasNotSent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map