@aoxborrow/registrar-client 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -1078,8 +1078,8 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
           message: `${domainName} is not a zone in this account; DNS is managed via the Zones API`
         };
       }
-      const dnsPath = `/zones/${encodeURIComponent(zone.id)}/dns_records`;
-      const list = await this.http.request({ path: dnsPath, ...opts });
+      const dnsPath2 = `/zones/${encodeURIComponent(zone.id)}/dns_records`;
+      const list = await this.http.request({ path: dnsPath2, ...opts });
       if (!list.success) {
         return {
           success: false,
@@ -1090,7 +1090,7 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
         if (!rec.id) continue;
         const del = await this.http.request({
           method: "DELETE",
-          path: `${dnsPath}/${encodeURIComponent(rec.id)}`,
+          path: `${dnsPath2}/${encodeURIComponent(rec.id)}`,
           ...opts
         });
         if (!del.success) {
@@ -1106,7 +1106,7 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
         if (type === "NS" && name === zone.name) continue;
         const create = await this.http.request({
           method: "POST",
-          path: dnsPath,
+          path: dnsPath2,
           body: toCfDnsBody(record, type, name),
           ...opts
         });
@@ -1775,6 +1775,527 @@ function toContact(c) {
   return contact;
 }
 
+// src/registrars/domain101.ts
+var Domain101HttpClient = class extends HttpClient {
+  async request(req) {
+    try {
+      return await super.request(req);
+    } catch (error) {
+      if (error instanceof AuthorizationError) {
+        const scope = requiredScope(req);
+        if (!scope || error.providerCode !== "INSUFFICIENT_PERMISSIONS") throw error;
+        const scoped = new AuthorizationError(
+          `101domain: this API key does not have the ${scope} scope. Create a key with ${scope} to ${SCOPE_PURPOSE[scope]}.`
+        );
+        scoped.providerCode = error.providerCode;
+        throw scoped;
+      }
+      if (error instanceof OutcomeUnknownError)
+        throw new OutcomeUnknownError(
+          "101domain: the registrar did not confirm this change. Re-read the domain before trying again.",
+          { feature: error.feature }
+        );
+      if (error instanceof ParsingError) throw new ParsingError("101domain: invalid JSON response");
+      if (error instanceof ConnectionError)
+        throw new ConnectionError("101domain: network request failed", { notSent: error.notSent });
+      throw error;
+    }
+  }
+  async toStatusError(response, url) {
+    const detail = await errorDetail(response);
+    const error = await super.toStatusError(
+      new Response(null, { status: response.status, headers: response.headers }),
+      url
+    );
+    if (detail) {
+      error.message = `101domain: ${detail.message}`;
+      error.providerCode = detail.code;
+    } else if (response.status === 403) {
+      error.message = "101domain: the request was refused before reaching the API (403 without an API error)";
+    }
+    return error;
+  }
+};
+var SCOPE_PURPOSE = {
+  domains_read: "read the domain portfolio",
+  domains_write: "change URL forwarding",
+  dns_read: "read DNS records and nameservers",
+  dns_write: "change DNS records and nameservers"
+};
+function requiredScope(req) {
+  const write = !REST_SAFE_METHODS.includes((req.method ?? "GET").toUpperCase());
+  if (req.path.startsWith("/dns/")) return write ? "dns_write" : "dns_read";
+  if (req.path === "/domains" || /^\/domains\/[^/]+(?:\/forwarding)?$/.test(req.path))
+    return write ? "domains_write" : "domains_read";
+  return void 0;
+}
+async function errorDetail(response) {
+  try {
+    const body = await response.json();
+    if (typeof body?.code !== "string" || typeof body.message !== "string" || !body.message)
+      return null;
+    return { code: body.code, message: body.message.replace(/\s+/g, " ").slice(0, 200) };
+  } catch {
+    return null;
+  }
+}
+var Domain101Registrar = class extends BaseRegistrar {
+  name = "101domain";
+  static safeMethods = REST_SAFE_METHODS;
+  static displayName = "101domain";
+  static website = "101domain.com";
+  static supportsSandbox = false;
+  static configFields = [
+    { name: "apiKey", label: "API key", type: "password", required: true }
+  ];
+  static helpText = "Create a Bearer API key under My Account > Developer Tools - API & MCP. Use domains_read and dns_read for reads; dns_write for DNS/nameservers and domains_write for forwarding. Only a primary account with 2FA or SSO can create keys. Keys expire after at most one year. Registration, renewal, auto-renew, privacy, lock, contacts and transfers are not available through this API.";
+  static extendedFeatures = [
+    Feature.GetDomainForwarding,
+    Feature.SetDomainForwarding
+  ];
+  constructor(credentials, options) {
+    const apiKey = credentials.apiKey?.trim() ?? "";
+    if (/[\r\n]/.test(apiKey)) throw new ConfigurationError("101domain: invalid API key format");
+    const config = {
+      baseUrl: selectBaseUrl("101domain", options?.environment, {
+        production: "https://api.101domain.com/v1"
+      }),
+      headers: { Authorization: `Bearer ${apiKey}` }
+    };
+    super(credentials, config, options);
+    this.http = new Domain101HttpClient({
+      ...config,
+      safeMethods: REST_SAFE_METHODS,
+      options: this.options
+    });
+  }
+  async testConnection(opts) {
+    try {
+      await this.request({
+        path: "/domains",
+        query: { page: 1, per_page: 1 },
+        ...opts
+      });
+      return { success: true, message: "Connection successful" };
+    } catch (error) {
+      return { success: false, message: toRegistrarError(error).message };
+    }
+  }
+  async listDomains(opts) {
+    const { search, detailed: _detailed, ...requestOpts } = opts ?? {};
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let page = 1; ; page++) {
+      const response = await this.request({
+        path: "/domains",
+        query: { page, per_page: 50 },
+        ...requestOpts
+      });
+      if (!Array.isArray(response.data)) throw invalid("domain list");
+      const pagination = response.meta?.pagination;
+      if (!pagination || pagination.current_page !== page || !Number.isInteger(pagination.total_pages) || pagination.total_pages < 0 || pagination.total_pages > 1e5 || !Number.isInteger(pagination.total) || pagination.total < 0)
+        throw invalid("pagination");
+      for (const raw of response.data) {
+        const domain = toDomain(raw);
+        if (seen.has(domain.domainName)) throw invalid("duplicate domain across pages");
+        seen.add(domain.domainName);
+        result.push(domain);
+      }
+      if (page >= pagination.total_pages) {
+        if (result.length !== pagination.total) throw invalid("incomplete portfolio");
+        return filterDomains(
+          result.filter((d) => !d.deleted),
+          search
+        );
+      }
+      if (!response.data.length) throw invalid("empty intermediate page");
+    }
+  }
+  async getDomain(domainName, opts) {
+    const domain = toDomain(
+      (await this.request({ path: domainPath(domainName), ...opts })).data
+    );
+    if (domain.domainName !== normalizeDomain(domainName)) throw invalid("domain identity");
+    return domain;
+  }
+  async getNameservers(domainName, opts) {
+    const raw = (await this.request({ path: `${dnsPath(domainName)}/nameservers`, ...opts })).data;
+    if (!Array.isArray(raw) || raw.some((n) => typeof n !== "string")) throw invalid("nameservers");
+    return raw.map((n) => n.toLowerCase());
+  }
+  async updateNameservers(domainName, nameservers, opts) {
+    const normalized = nameservers.map((n) => n.trim().toLowerCase());
+    if (normalized.length < 2 || normalized.length > 13 || new Set(normalized).size !== normalized.length || normalized.some((n) => !/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9-]+$/.test(n)))
+      throw new ConfigurationError("101domain: provide 2\u201313 distinct nameserver hostnames");
+    try {
+      const response = await this.request({
+        ...opts,
+        method: "PUT",
+        path: `${dnsPath(domainName)}/nameservers`,
+        body: { nameservers: normalized }
+      });
+      if (response.data?.change_status === "pending")
+        return {
+          success: true,
+          pending: true,
+          message: "Nameserver change submitted; pending registry processing. Re-read nameservers to confirm completion."
+        };
+      if (response.data?.change_status === "failed")
+        return { success: false, message: "101domain rejected the nameserver change" };
+      if (response.data?.change_status !== "completed")
+        throw new OutcomeUnknownError(
+          "101domain: invalid nameserver change confirmation. Re-read nameservers before trying again."
+        );
+      return { success: true, message: "Nameservers already configured as requested" };
+    } catch (error) {
+      return failed(error);
+    }
+  }
+  async checkAvailability(domainNames, opts) {
+    const names = [...new Set(domainNames.map(normalizeDomain))];
+    const result = [];
+    for (const domains of chunks(names, 50)) {
+      const response = await this.request({
+        ...opts,
+        method: "POST",
+        path: "/domains/bulk-search",
+        body: { domains, pricing_term: 1 }
+      });
+      if (!Array.isArray(response.data) || (response.invalid?.length ?? 0) > 0)
+        throw invalid("availability results");
+      const found = /* @__PURE__ */ new Set();
+      for (const raw of response.data) {
+        if (typeof raw.domain_name !== "string" || typeof raw.available !== "boolean")
+          throw invalid("availability result");
+        const domainName = normalizeDomain(raw.domain_name);
+        if (!domains.includes(domainName) || found.has(domainName))
+          throw invalid("availability identity");
+        found.add(domainName);
+        const price2 = oneYear(raw.pricing);
+        result.push({
+          domainName,
+          available: raw.available,
+          premium: price2?.premium,
+          price: amount(price2?.register),
+          renewalPrice: amount(price2?.renew),
+          currency: price2?.currency,
+          period: 1
+        });
+      }
+      if (found.size !== domains.length) throw invalid("incomplete availability results");
+    }
+    return result;
+  }
+  async getPricing(tldOrDomain, opts) {
+    const name = normalizeDomain(tldOrDomain);
+    if (name.startsWith(".") || !name.includes(".")) {
+      const tld = name.replace(/^\./, "");
+      const response2 = await this.request({
+        path: `/tlds/${encodeURIComponent("." + tld)}`,
+        query: { pricing_terms: "1" },
+        ...opts
+      });
+      const price3 = oneYear(response2.data?.pricing);
+      if (!price3) throw new NotFoundError("101domain: no one-year pricing for this TLD");
+      return {
+        tld,
+        currency: price3.currency,
+        registration: amount(price3.register),
+        renewal: amount(price3.renew),
+        transfer: amount(price3.transfer)
+      };
+    }
+    const response = await this.request({
+      path: "/domains/search",
+      query: { domain_name: name, pricing_terms: "1" },
+      ...opts
+    });
+    const raw = response.data;
+    if (!raw || normalizeDomain(raw.domain_name) !== name) throw invalid("pricing identity");
+    const price2 = oneYear(raw.pricing);
+    if (!price2) throw new NotFoundError("101domain: pricing unavailable for this domain");
+    return {
+      tld: name.slice(name.indexOf(".") + 1),
+      currency: price2.currency,
+      registration: amount(price2.register),
+      renewal: amount(price2.renew),
+      transfer: amount(price2.transfer)
+    };
+  }
+  async getDnsRecords(domainName, opts) {
+    return (await this.rawRecords(domainName, opts)).map(fromRecord);
+  }
+  // Reconcile by content-derived IDs. Preserve unchanged records, edit by ID, create additions
+  // before removing stale records, and stop on any failed batch. Never retry an
+  // uncertain write. This replaces the custom records, not the apex NS delegation.
+  async setDnsRecords(domainName, records, opts) {
+    const desired = records.map((r) => recordSpec(r, domainName));
+    const unique = desired.filter(
+      (r, i) => desired.findIndex((other) => recordSignature(other) === recordSignature(r)) === i
+    );
+    let changed = false;
+    try {
+      const stale = (await this.rawRecords(domainName, opts)).map((raw) => ({ raw, spec: recordSpec(fromRecord(raw), domainName, false) })).filter(({ spec }) => !(spec.type === "NS" && spec.name === ""));
+      const additions = [];
+      const edits = [];
+      for (const record of unique) {
+        const index = stale.findIndex(
+          ({ spec }) => recordSignature(spec) === recordSignature(record)
+        );
+        if (index >= 0) stale.splice(index, 1);
+        else {
+          const priorIndex = stale.findIndex(
+            ({ spec }) => spec.type === record.type && spec.name === record.name
+          );
+          const prior = priorIndex >= 0 ? stale.splice(priorIndex, 1)[0].raw : void 0;
+          if (prior?.proxied) record.proxied = true;
+          if (record.ttl === 1 && record.proxied !== true)
+            throw new ConfigurationError(
+              "101domain: automatic TTL requires an existing proxied SWA record"
+            );
+          if (prior) {
+            const edit = { ...record, id: prior.id };
+            delete edit.name;
+            delete edit.type;
+            edits.push(edit);
+          } else additions.push(record);
+        }
+      }
+      for (const batch of chunks(edits, 25)) {
+        const response = await this.request({
+          ...opts,
+          method: "PATCH",
+          path: `${dnsPath(domainName)}/records`,
+          body: { records: batch }
+        });
+        if (!Array.isArray(response.data) || response.data.length !== batch.length || new Set(response.data.map((r) => r?.old_id)).size !== batch.length || response.data.some(
+          (r) => !r || !batch.some((edit) => edit.id === r.old_id) || typeof r.id !== "string" || !r.id
+        ))
+          throw new OutcomeUnknownError(
+            "101domain: invalid DNS edit confirmation. Re-read the zone before trying again."
+          );
+        changed = true;
+      }
+      for (const batch of chunks(additions, 25)) {
+        await this.request({
+          ...opts,
+          method: "POST",
+          path: `${dnsPath(domainName)}/records`,
+          body: { records: batch }
+        });
+        changed = true;
+      }
+      for (const batch of chunks(stale, 25)) {
+        await this.request({
+          ...opts,
+          method: "DELETE",
+          path: `${dnsPath(domainName)}/records`,
+          body: { ids: batch.map(({ raw }) => raw.id) }
+        });
+        changed = true;
+      }
+      return { success: true, message: "DNS records updated successfully" };
+    } catch (error) {
+      const result = failed(error);
+      if (!changed && !result.outcome) return result;
+      return {
+        ...result,
+        message: `${result.message}. DNS replacement is not atomic; read the zone before retrying.`
+      };
+    }
+  }
+  async getDomainForwarding(domainName, opts) {
+    const raw = (await this.request({
+      path: domainPath(domainName),
+      ...opts
+    })).data;
+    if (!raw || normalizeDomain(raw.domain_name) !== normalizeDomain(domainName))
+      throw invalid("domain identity");
+    const forward = raw.web_forwarding;
+    if (forward === null || forward?.destination === null && forward.type === null) return [];
+    if (!forward || typeof forward.destination !== "string" || forward.type !== "301" && forward.type !== "cloak")
+      throw invalid("forwarding");
+    return [
+      {
+        host: "@",
+        url: forward.destination,
+        type: forward.type === "301" ? "permanent" : "masked"
+      }
+    ];
+  }
+  async setDomainForwarding(domainName, forwards, opts) {
+    if (forwards.length > 1 || forwards.some((f) => f.host !== "@" || f.type !== "permanent"))
+      throw new ConfigurationError(
+        "101domain: only one permanent apex forwarding rule is supported"
+      );
+    if (forwards.length) {
+      let url;
+      try {
+        url = new URL(forwards[0].url);
+      } catch {
+        throw new ConfigurationError("101domain: forwarding needs a valid HTTP(S) URL");
+      }
+      if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+        throw new ConfigurationError("101domain: forwarding needs a valid HTTP(S) URL");
+    }
+    try {
+      const existing = await this.getDomainForwarding(domainName, opts);
+      const path = `${domainPath(domainName)}/forwarding`;
+      if (!forwards.length) {
+        if (existing.length) await this.request({ ...opts, method: "DELETE", path });
+      } else if (existing[0]?.url !== forwards[0].url || existing[0]?.type !== "permanent") {
+        await this.request({
+          ...opts,
+          method: existing.length ? "PATCH" : "POST",
+          path,
+          body: { destination: forwards[0].url, type: "301" }
+        });
+      }
+      return {
+        success: true,
+        message: forwards.length ? "URL forwarding updated" : "URL forwarding cleared"
+      };
+    } catch (error) {
+      return failed(error);
+    }
+  }
+  async request(req) {
+    const raw = await this.http.request(req);
+    if (!raw || typeof raw !== "object" || raw.status !== "success" || !("data" in raw)) {
+      if (req.call?.intent === "write" && !REST_SAFE_METHODS.includes(req.method ?? "GET"))
+        throw new OutcomeUnknownError(
+          "101domain: invalid write confirmation. Re-read the domain before trying again."
+        );
+      throw invalid("response envelope");
+    }
+    return raw;
+  }
+  async rawRecords(domainName, opts) {
+    const raw = (await this.request({ path: `${dnsPath(domainName)}/records`, ...opts })).data;
+    if (!Array.isArray(raw) || raw.some(
+      (r) => !r || typeof r.id !== "string" || !r.id || typeof r.name !== "string" || typeof r.value !== "string" || typeof r.type !== "string" || !Number.isInteger(r.ttl)
+    ))
+      throw invalid("DNS records");
+    if (new Set(raw.map((r) => r.id)).size !== raw.length) throw invalid("duplicate DNS ids");
+    return raw;
+  }
+};
+function invalid(part) {
+  return new InvalidResponseError(`101domain: invalid ${part}`);
+}
+function failed(error) {
+  return {
+    success: false,
+    message: toRegistrarError(error).message,
+    ...error instanceof OutcomeUnknownError ? { outcome: "unknown" } : {}
+  };
+}
+function domainPath(name) {
+  return `/domains/${encodeURIComponent(normalizeDomain(name))}`;
+}
+function dnsPath(name) {
+  return `/dns/${encodeURIComponent(normalizeDomain(name))}`;
+}
+function chunks(items, size) {
+  const result = [];
+  for (let i = 0; i < items.length; i += size) result.push(items.slice(i, i + size));
+  return result;
+}
+function oneYear(pricing) {
+  if (pricing == null) return void 0;
+  if (!Array.isArray(pricing)) throw invalid("pricing");
+  return pricing.find((p) => p?.term_years === 1);
+}
+function amount(raw) {
+  if (raw == null) return void 0;
+  if (!/^\d+(?:\.\d+)?$/.test(raw)) throw invalid("price");
+  const value = Number(raw);
+  if (!Number.isFinite(value)) throw invalid("price");
+  return value;
+}
+function toDomain(raw) {
+  if (!raw || typeof raw.domain_name !== "string" || !raw.domain_name.trim())
+    throw invalid("domain");
+  return createDomain({
+    domainName: normalizeDomain(raw.domain_name),
+    registrar: "101domain",
+    status: raw.status,
+    createdDate: raw.registered_at,
+    expirationDate: raw.expires_at,
+    autoRenew: raw.auto_renew,
+    locked: raw.registry_statuses?.some((s) => /^clientTransferProhibited$/i.test(s)),
+    nameservers: raw.nameservers,
+    deleted: !isHeld(raw)
+  });
+}
+var GONE = /* @__PURE__ */ new Set(["DELETED", "CANCELLED", "DENIED", "XFER_AWAY"]);
+function isHeld(raw) {
+  const status = raw.status?.toUpperCase() ?? "";
+  return !GONE.has(status) && !status.startsWith("XFER_IN_") && raw.registered_at != null;
+}
+function fromRecord(raw) {
+  const common = { name: raw.name || "@", type: raw.type, ttl: raw.ttl };
+  if (raw.type === "MX") {
+    const match = /^(\d+)\s+(.+)$/.exec(raw.value);
+    if (!match) throw invalid("MX record");
+    return { ...common, value: match[2], priority: Number(match[1]) };
+  }
+  if (raw.type === "SRV") {
+    const match = /^(\d+)\s+(\d+)\s+(\d+)\s+(.+)$/.exec(raw.value);
+    if (!match) throw invalid("SRV record");
+    return {
+      ...common,
+      value: match[4],
+      priority: Number(match[1]),
+      weight: Number(match[2]),
+      port: Number(match[3])
+    };
+  }
+  return { ...common, value: raw.value };
+}
+function recordSpec(record, domain, strict = true) {
+  const type = record.type.toUpperCase();
+  const zone = normalizeDomain(domain);
+  let name = record.name.trim().toLowerCase().replace(/\.$/, "");
+  if (name === zone || name === "@") name = "";
+  else if (name.endsWith("." + zone)) name = name.slice(0, -zone.length - 1);
+  const reject = (message) => {
+    if (strict) throw new ConfigurationError(`101domain: ${message}`);
+  };
+  if (!["A", "AAAA", "CNAME", "NS", "MX", "TXT", "SRV", "CAA"].includes(type) || type === "NS" && !name)
+    reject("unsupported DNS type or apex NS record");
+  const ttl = record.ttl ?? 3600;
+  if (!Number.isInteger(ttl) || ttl !== 1 && ttl < 300)
+    reject("DNS TTL must be at least 300 seconds");
+  const result = { name, type, ttl };
+  if (type === "MX" || type === "SRV") {
+    if (!Number.isInteger(record.priority) || record.priority < 0 || record.priority > 65535)
+      reject("MX/SRV priority is required");
+    result.priority = record.priority;
+    result.target = record.value;
+    if (type === "SRV") {
+      if (![record.weight, record.port].every((n) => Number.isInteger(n) && n >= 0 && n <= 65535))
+        reject("SRV weight and port are required");
+      result.weight = record.weight;
+      result.port = record.port;
+    }
+  } else if (type === "CAA") {
+    const match = /^(\d+)\s+(\w+)\s+"([\s\S]*)"$/.exec(record.value);
+    if (!match || Number(match[1]) > 255) {
+      reject("CAA needs flags, tag and quoted value");
+      result.value = record.value;
+    } else {
+      result.flag = Number(match[1]);
+      result.tag = match[2];
+      result.value = match[3];
+    }
+  } else result.value = record.value;
+  return result;
+}
+function recordSignature(record) {
+  return JSON.stringify(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+
 // src/registrars/dynadot.ts
 var DYNADOT_DEFAULT_NS = ["ns1.dynadot.com", "ns2.dynadot.com"];
 var SEARCH_BATCH_SIZE = 100;
@@ -2452,12 +2973,12 @@ function isPrivacyOn(privacy) {
 }
 function oneYearPrice(prices) {
   if (!prices?.length) return void 0;
-  const oneYear = prices.find((p) => /\b1\s*year\b/i.test(p.unit ?? "")) ?? prices[0];
+  const oneYear2 = prices.find((p) => /\b1\s*year\b/i.test(p.unit ?? "")) ?? prices[0];
   return {
-    currency: oneYear.currency,
-    registration: toNumber(oneYear.registration_price),
-    renewal: toNumber(oneYear.renewal_price),
-    transfer: toNumber(oneYear.transfer_price)
+    currency: oneYear2.currency,
+    registration: toNumber(oneYear2.registration_price),
+    renewal: toNumber(oneYear2.renewal_price),
+    transfer: toNumber(oneYear2.transfer_price)
   };
 }
 function extractNameservers(glue) {
@@ -2747,8 +3268,8 @@ var GandiRegistrar = class extends BaseRegistrar {
         available: status.startsWith("available"),
         premium: status.includes("premium") || price2?.type === "premium"
       };
-      const amount = pickPrice(price2);
-      if (amount != null) result.price = amount;
+      const amount2 = pickPrice(price2);
+      if (amount2 != null) result.price = amount2;
       if (resp.currency) result.currency = resp.currency;
       if (price2?.duration_unit === "y" && price2.min_duration != null) {
         result.period = price2.min_duration;
@@ -5261,7 +5782,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   }
   async getAuthCode(domainName, opts) {
     const result = await this.http.request({
-      path: `${domainPath(domainName)}:getAuthCode`,
+      path: `${domainPath2(domainName)}:getAuthCode`,
       ...opts
     });
     if (!result?.authCode) throw new InvalidResponseError("namecom: missing authorization code");
@@ -5356,7 +5877,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
     validYears(years);
     const pricing = await this.domainPricing(domainName, years, opts);
     return this.purchase(
-      `${domainPath(domainName)}:renew`,
+      `${domainPath2(domainName)}:renew`,
       {
         years,
         purchasePrice: purchaseQuote(pricing, "renewalPrice")
@@ -5401,7 +5922,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   }
   updateNameservers(domainName, nameservers, opts) {
     return this.mutate(
-      { method: "POST", path: `${domainPath(domainName)}:setNameservers`, body: { nameservers } },
+      { method: "POST", path: `${domainPath2(domainName)}:setNameservers`, body: { nameservers } },
       opts
     );
   }
@@ -5432,14 +5953,14 @@ var NamecomRegistrar = class extends BaseRegistrar {
     return this.mutate(
       {
         method: "POST",
-        path: `${domainPath(domainName)}:setContacts`,
+        path: `${domainPath2(domainName)}:setContacts`,
         body: { contacts: toContacts(contacts) }
       },
       opts
     );
   }
   async getDnsRecords(domainName, opts) {
-    return (await this.pages(`${domainPath(domainName)}/records`, "records", opts)).map(fromRecord);
+    return (await this.pages(`${domainPath2(domainName)}/records`, "records", opts)).map(fromRecord2);
   }
   // No bulk replace endpoint. Reconcile by id: preserve identical records, update
   // existing type/host pairs, create additions, then delete stale records. This
@@ -5447,7 +5968,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   async setDnsRecords(domainName, records, opts) {
     const desired = records.map(toRecord).filter((record, index, all) => all.findIndex((other) => sameRecord(other, record)) === index);
     try {
-      const path = `${domainPath(domainName)}/records`;
+      const path = `${domainPath2(domainName)}/records`;
       const existing = await this.pages(path, "records", opts);
       if (existing.some((r) => !Number.isInteger(r.id) || r.id <= 0))
         throw new InvalidResponseError("namecom: DNS response missing record ids");
@@ -5484,14 +6005,14 @@ var NamecomRegistrar = class extends BaseRegistrar {
     }
   }
   patchDomain(domainName, body, opts) {
-    return this.mutate({ method: "PATCH", path: domainPath(domainName), body }, opts);
+    return this.mutate({ method: "PATCH", path: domainPath2(domainName), body }, opts);
   }
   rawDomain(domainName, opts) {
-    return this.http.request({ path: domainPath(domainName), ...opts });
+    return this.http.request({ path: domainPath2(domainName), ...opts });
   }
   domainPricing(domainName, years, opts) {
     return this.http.request({
-      path: `${domainPath(domainName)}:getPricing`,
+      path: `${domainPath2(domainName)}:getPricing`,
       query: { years },
       ...opts
     });
@@ -5607,7 +6128,7 @@ function toContacts(contacts) {
     throw new ConfigurationError("namecom: at least one contact is required");
   return result;
 }
-function domainPath(domainName) {
+function domainPath2(domainName) {
   return `/domains/${encodeURIComponent(normalizeDomain(domainName))}`;
 }
 function validYears(years) {
@@ -5647,7 +6168,7 @@ function toRecord(r) {
     ...["MX", "SRV"].includes(type) ? { priority: r.priority ?? 0 } : {}
   };
 }
-function fromRecord(r) {
+function fromRecord2(r) {
   const type = r.type.toUpperCase();
   const record = { type, name: r.host || "@", value: r.answer, ttl: r.ttl };
   if (type === "MX" || type === "SRV") record.priority = r.priority ?? 0;
@@ -7468,16 +7989,17 @@ function toSpaceshipContact(c) {
 
 // src/registrars/index.ts
 var registrars = {
-  cloudflare: CloudflareRegistrar,
-  dynadot: DynadotRegistrar,
-  gandi: GandiRegistrar,
-  godaddy: GoDaddyRegistrar,
-  namebright: NameBrightRegistrar,
-  namecheap: NamecheapRegistrar,
-  namecom: NamecomRegistrar,
-  namesilo: NameSiloRegistrar,
-  porkbun: PorkbunRegistrar,
-  spaceship: SpaceshipRegistrar
+  "101domain": Domain101Registrar,
+  "cloudflare": CloudflareRegistrar,
+  "dynadot": DynadotRegistrar,
+  "gandi": GandiRegistrar,
+  "godaddy": GoDaddyRegistrar,
+  "namebright": NameBrightRegistrar,
+  "namecheap": NamecheapRegistrar,
+  "namecom": NamecomRegistrar,
+  "namesilo": NameSiloRegistrar,
+  "porkbun": PorkbunRegistrar,
+  "spaceship": SpaceshipRegistrar
 };
 function createRegistrar(name, credentials, options) {
   const RegistrarClass = registrars[name];
@@ -7495,6 +8017,7 @@ exports.ConfigurationError = ConfigurationError;
 exports.ConnectionError = ConnectionError;
 exports.ConsentRequiredError = ConsentRequiredError;
 exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.Domain101Registrar = Domain101Registrar;
 exports.DynadotRegistrar = DynadotRegistrar;
 exports.EXTENDED_FEATURES = EXTENDED_FEATURES;
 exports.FEATURE_CALLS = FEATURE_CALLS;