Domains

List audit entries (optionally scoped to a domain; default limit 20).

list(input?: OrgScoped<{ domainId?: string; limit?: number; }>): Promise<{ items: DomainsAuditEntry[]; }>;

Delete a record by id. 404 `not_found`.

delete(input: OrgScoped<{ id: string; domainId?: string; }>): Promise<{ ok: true; }>;

List a domain's DNS records.

list(input: OrgScoped<{ domainId: string; }>): Promise<{ records: DomainsDnsRecord[]; }>;

Create or update a record (matched by `id`, or by domain+type+name).

upsert(input: OrgScoped<{ id?: string; domainId: string; type: string; name: string; value: string; ttl?: number; }>): Promise<{ record: DomainsDnsRecord; }>;

Create a contact.

create(input: OrgScoped<{ name: string; email: string; organization?: string; street?: string; city?: string; postcode?: string; country?: string; }>): Promise<{ contact: DomainContact; }>;

Delete a contact by id. 404 `not_found`.

delete(input: OrgScoped<{ id: string; }>): Promise<{ ok: true; }>;

List the org's contacts.

list(input?: OrgScoped): Promise<{ contacts: DomainContact[]; }>;

Update a contact. 404 `not_found`.

update(input: OrgScoped<{ id: string; name?: string; email?: string; organization?: string; street?: string; city?: string; postcode?: string; country?: string; }>): Promise<{ contact: DomainContact; }>;

Get one domain by id (`domainId` or `id`). 404 `not_found`.

get(input: OrgScoped<{ domainId?: string; id?: string; }>): Promise<{ domain: Domain; }>;

List the org's domains.

list(input?: OrgScoped): Promise<{ domains: Domain[]; }>;

Update a domain's auto_renew / locked / status. 404 `not_found`.

update(input: OrgScoped<{ id: string; auto_renew?: boolean; locked?: boolean; status?: string; }>): Promise<{ domain: Domain; }>;

Add a domain: generates + KEK-encrypts a DKIM key, returns the row + the DNS records to publish. 409 `domain_taken` if already added to the org.

add(input: OrgScoped<{ domain: string; }>): Promise<{ domain: MailDomain; dnsRecords: MailDnsRecord[]; }>;

The DNS records the org must publish for this domain.

dnsRecords(input: OrgScoped<{ id: string; }>): Promise<MailDomainsDnsRecordsResult>;

get(input: OrgScoped<{ id: string; }>): Promise<{ domain: MailDomain; }>;

list(input?: OrgScoped): Promise<{ domains: MailDomain[]; }>;

remove(input: OrgScoped<{ id: string; }>): Promise<{ ok: true; }>;

Resolve live DNS and update the verification state. `verified` = SPF + DKIM.

verify(input: OrgScoped<{ id: string; }>): Promise<MailDomainsVerifyResult>;

List the org's invoices.

list(input?: OrgScoped): Promise<{ invoices: DomainsInvoice[]; }>;

List a domain's nameservers. 404 `not_found`.

list(input: OrgScoped<{ domainId: string; }>): Promise<{ nameservers: DomainNameserver[]; }>;

Replace a domain's nameservers (min 2). 404 `not_found`.

update(input: OrgScoped<{ domainId: string; nameservers: string[]; }>): Promise<{ nameservers: DomainNameserver[]; }>;

Get the org's payment method.

get(input?: OrgScoped): Promise<{ paymentMethod: DomainsPaymentMethod | null; }>;

Upsert the org's payment method.

update(input: OrgScoped<{ brand: string; last4: string; exp_month: number; exp_year: number; name?: string; }>): Promise<{ paymentMethod: DomainsPaymentMethod; }>;

Address autocomplete (stub; wired to Adrifact Geo later).

addressAutocomplete(input: OrgScoped<{ query: string; }>): Promise<{ suggestions: DomainAddressSuggestion[]; }>;

Check availability of a query (a bare label fans out over `tlds`, or a full fqdn checks just itself). Returns all `results` + the first as `result`.

checkAvailability(input: OrgScoped<{ query: string; tlds?: string[]; }>): Promise<{ results: DomainAvailabilityResult[]; result: DomainAvailabilityResult; }>;

Email-deliverability stats for a domain (stub; synthesised from SPF presence).

emailStats(input?: OrgScoped<{ domainId?: string; }>): Promise<{ stats: { configured: boolean; sent: number; delivered: number; bounced: number; domain?: string; }; }>;

Get the register/renew/transfer price for an fqdn.

getDomainPrice(input: OrgScoped<{ fqdn: string; }>): Promise<{ price: string; register: string; renew: string; transfer: string; premium: boolean; }>;

Import a BIND-style zone file into a domain's DNS records. 404 `not_found`.

importDnsZone(input: OrgScoped<{ domainId: string; zone: string; }>): Promise<{ imported: number; }>;

The TLD price table.

listPrices(input?: OrgScoped): Promise<{ rows: { tld: string; register: string; renew: string; transfer: string; }[]; }>;

Publish (mark live) a domain's DNS zone. 404 `not_found`.

publishDnsZone(input: OrgScoped<{ domainId: string; }>): Promise<{ ok: true; published: number; }>;

Register a domain (the composite service: domain + optional contact + DNS + invoice + audit, in one transaction). 409 `conflict` if already registered.

registerDomain(input: OrgScoped<{ domain: string; years?: number; auto_renew?: boolean; services?: string[]; registrant?: { name: string; email: string; }; }>): Promise<{ domain: string; id: string; status: string; expires_at: string | null; }>;

Renew a domain by `domainId` or `domain` (fqdn). 404 `not_found`.

renewDomain(input: OrgScoped<{ domainId?: string; domain?: string; years?: number; auto_renew?: boolean; }>): Promise<{ domain: string; expires_at: string | null; years: number; }>;

Set the transfer lock on a domain. 404 `not_found`.

setDomainLock(input: OrgScoped<{ domainId: string; locked: boolean; }>): Promise<{ domain: Domain; }>;

Start a transfer-in (needs an auth/EPP code).

transferDomain(input: OrgScoped<{ domain: string; authCode?: string; auth_code?: string; epp?: string; }>): Promise<{ transfer: DomainTransfer; }>;

Get the status of a transfer-in.

transferStatus(input: OrgScoped<{ fqdn: string; }>): Promise<{ transfer: DomainTransfer; }>;

Domains renewing within 90 days, soonest first.

upcomingRenewals(input?: OrgScoped): Promise<{ renewals: { id: string; fqdn: string; expires_at: string | null; amount: string; auto_renew: boolean; }[]; }>;

Usage meter (stub).

usage(input?: OrgScoped): Promise<{ usage: { used: number; limit: number; unit: string; period: string; }; }>;

WHOIS for an fqdn (own domain → full record; well-known → minimal; else null).

whois(input: OrgScoped<{ fqdn: string; }>): Promise<{ whois: Record<string, unknown> | null; }>;