@gusnips/one-click-dns 0.0.0-stage → 0.1.1

package/dist/hosts-B0_V4Ned.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The DNS hosts we know steps for. A closed list. Order is the order a picker shows them and a
+ * detection lists them in.
+ *
+ * `cpanel` and `namecheap-hosting` both hand the person cPanel's Zone Editor. `hostinger` and
+ * `cpanel` have no name server pattern, so DNS alone never names them: a person picks them by
+ * hand.
+ */
+declare const DNS_HOST_IDS: readonly ["cloudflare", "godaddy", "namecheap", "namecheap-hosting", "squarespace", "route53", "google-cloud-dns", "azure-dns", "ionos", "hostinger", "porkbun", "name-com", "dynadot", "namesilo", "gandi", "ovhcloud", "digitalocean", "hetzner", "vercel", "netlify", "wix", "wordpress-com", "cpanel", "bluehost", "hostgator", "hostgator-br", "siteground", "registro-br", "locaweb", "kinghost", "uol-host", "umbler", "dnsimple"];
+type DnsHostId = (typeof DNS_HOST_IDS)[number];
+/** The labels on the form of one record type. */
+interface DnsFields {
+    /** The box that takes the record's name. */
+    name: string | null;
+    /** The box that takes its value: a CNAME's target, or a TXT's text. */
+    value: string | null;
+}
+/**
+ * What goes wrong at a host, each with a sentence of its own in the app.
+ *
+ * - `proxyOff`: a record is proxied by default and the proxy hides it (Cloudflare);
+ * - `trailingDot`: without a dot at the end, the host adds the zone to a CNAME's target
+ *   (OVHcloud, Hetzner, DigitalOcean);
+ * - `quotedTxt`: the host wants straight quotes around a TXT value (Route 53, Hetzner);
+ * - `secondSave`: adding the record is not saving it (KingHost);
+ * - `advancedMode`: the basic mode can't add the record (Registro.br);
+ * - `oneSpf`: the host may already hold an SPF record, and a domain may have only one;
+ * - `shortName`: the name box takes only the part before the zone, and the host adds the rest.
+ *
+ * `trailingDot` and `quotedTxt` also change the value we hand over (`records.ts`).
+ */
+type DnsTrap = {
+    kind: "proxyOff";
+    field: string;
+    value: string;
+} | {
+    kind: "trailingDot";
+} | {
+    kind: "quotedTxt";
+} | {
+    kind: "secondSave";
+    button: string;
+} | {
+    kind: "advancedMode";
+    mode: string;
+} | {
+    kind: "oneSpf";
+} | {
+    kind: "shortName";
+};
+type DnsTrapKind = DnsTrap["kind"];
+interface DnsHost {
+    /** The brand, as the company writes it. */
+    name: string;
+    /** The host's name servers, as patterns over a lowercase name with no trailing dot. A set
+     *  of names belongs to this host only when every name matches one of them. Empty: no
+     *  pattern we may trust, so the host is reached by the picker alone. */
+    ns: readonly RegExp[];
+    /** The host's page for a zone's records, only where its own docs link one. */
+    link: string | null;
+    /** The menu, tab or button that opens the zone's records. */
+    open: string | null;
+    /** The button that starts a new record. */
+    add: string | null;
+    /** The button that saves it. */
+    save: string | null;
+    cname: DnsFields;
+    txt: DnsFields;
+    /** How the host writes the zone's own name in the name box: `"@"`, empty, or `"."`. `null`
+     *  when no page of the host says. */
+    root: "@" | "" | "." | null;
+    traps: readonly DnsTrap[];
+}
+declare const DNS_HOSTS: Record<DnsHostId, DnsHost>;
+/** The first trap of a kind a host has. */
+declare function trapOf<K extends DnsTrapKind>(host: DnsHost, kind: K): Extract<DnsTrap, {
+    kind: K;
+}> | undefined;
+/**
+ * The hosts a zone's name servers point at. A host fits when every name matches one of its
+ * patterns, so a set that mixes two hosts, or holds one name nobody claims, fits none. Names that
+ * several hosts share answer with all of them, in `DNS_HOST_IDS` order: the app shows the
+ * choice and never guesses. An empty list is a host we don't know.
+ */
+declare function detectDnsHosts(nameservers: readonly string[]): DnsHostId[];
+/** The zone whose name servers answered: the nearest name at or above the hostname that has NS
+ *  records of its own. Records are added in this zone, named relative to it. */
+interface DnsZone {
+    zone: string;
+    /** The zone's name servers, lowercase, without the trailing dot, sorted. */
+    nameservers: string[];
+}
+/**
+ * What we read from DNS about where a domain's records are edited. `hosts` says what the names
+ * mean:
+ * - one id: a host we know;
+ * - several: the names fit more than one (Netlify and older Squarespace zones share NS1's
+ *   names, Google Cloud DNS and Squarespace domains moved from Google Domains share Google's),
+ *   so we do not guess;
+ * - none: names no host we know uses, or a mix of hosts. Show the names and ask.
+ */
+interface DnsHostReading extends DnsZone {
+    hosts: DnsHostId[];
+}
+
+export { type DnsHostId as D, DNS_HOSTS as a, DNS_HOST_IDS as b, type DnsFields as c, type DnsHost as d, type DnsHostReading as e, type DnsTrap as f, type DnsTrapKind as g, type DnsZone as h, detectDnsHosts as i, trapOf as t };