domani 0.4.12 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1582 @@
+export interface DomaniOptions {
+    /** API key from https://domani.run. Sent as `Authorization: Bearer <apiKey>`. */
+    apiKey: string;
+    /** Override the API base URL. Defaults to https://domani.run. */
+    baseUrl?: string;
+    /** Custom fetch implementation (defaults to global fetch). */
+    fetch?: typeof fetch;
+}
+/** Structured API error - mirrors the `apiError()` shape returned by the API. */
+export declare class DomaniError extends Error {
+    status: number;
+    code: string;
+    hint?: string;
+    documentation_url?: string;
+    constructor(status: number, body: any);
+}
+export interface Error {
+    /** Human-readable error message */
+    error: string;
+    /** Machine-readable error code */
+    code: "MISSING_API_KEY" | "INVALID_API_KEY" | "EXPIRED_API_KEY" | "MISSING_PARAMETER" | "INVALID_DOMAIN" | "PAYMENT_REQUIRED" | "DOMAIN_UNAVAILABLE" | "RATE_LIMIT_EXCEEDED" | "USER_EXISTS" | "NOT_FOUND" | "UNKNOWN_PROVIDER" | "UNKNOWN_METHOD" | "TARGET_REQUIRED" | "INVALID_PARAMETER" | "CONTACT_REQUIRED" | "INVALID_CONTACT" | "INSUFFICIENT_SCOPE" | "SCOPE_ESCALATION" | "DOMAIN_EXISTS" | "DOMAIN_NOT_ACTIVE" | "UNSUPPORTED_TLD" | "NOT_AVAILABLE" | "ALREADY_REGISTERED" | "TRANSFER_NOT_ELIGIBLE" | "ALREADY_LISTED" | "LISTING_SOLD" | "SELF_PURCHASE" | "DESCRIPTION_TOO_LONG" | "DEAL_NOT_FOUND" | "INVALID_DEAL_STATE" | "EPP_ATTEMPTS_EXCEEDED" | "ACTIVE_DEAL_EXISTS";
+    /** Actionable recovery guidance for the caller */
+    hint?: string;
+    /** CLI command to resolve the error (e.g. 'domani login', 'domani billing'). Present in CLI --json output. */
+    fix_command?: string;
+    /** Link to relevant documentation */
+    documentation_url: string;
+    /** URL to resolve the issue (e.g. add payment method) */
+    setup_url?: string;
+    /** URL to resolve the issue (alias for setup_url in CLI --json output) */
+    fix_url?: string;
+    /** Seconds until retry is allowed (present on 429 responses) */
+    retry_after?: number;
+}
+export interface SearchResult {
+    /** Whether the domain is available for registration */
+    available: boolean;
+    /** Full domain name including TLD */
+    domain: string;
+    /** Registration price in the specified currency */
+    price: number;
+    /** ISO 4217 currency code (always USD) */
+    currency: string;
+    /** True if RDAP lookup failed (availability unknown) */
+    error?: boolean;
+    /** Present when the domain is listed for sale (either on Domani marketplace or detected on an external aftermarket) */
+    for_sale?: {
+        price: number;
+        currency: string;
+        source: string;
+        buyable: boolean;
+        url?: string;
+        description?: string;
+    };
+}
+export interface TldInfo {
+    /** Top-level domain without dot prefix */
+    tld: string;
+    /** First-year registration price in USD */
+    registration: number;
+    /** Annual renewal price in USD */
+    renewal: number;
+    /** Transfer price in USD */
+    transfer: number;
+}
+export interface DnsRecord {
+    /** DNS record type */
+    type: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS" | "SRV" | "CAA";
+    /** Record name (@ for root, or subdomain) */
+    name: string;
+    /** Record value (IP address, hostname, etc.) */
+    value: string;
+    /** Time to live in seconds */
+    ttl: number;
+    /** Priority value (required for MX records) */
+    priority?: number;
+}
+export interface DomainRecord {
+    domain: string;
+    /** Current registration status */
+    status: "active" | "expired" | "pending";
+    /** Whether auto-renew is enabled */
+    auto_renew: boolean;
+    purchasedAt: string;
+    expiresAt: string;
+    /** Whether email is set up for this domain */
+    emailEnabled: boolean;
+    /** Whether email DNS records have been verified */
+    emailVerified: boolean;
+    /** When email DNS was verified (null if not yet verified) */
+    emailVerifiedAt?: string | null;
+    /** Number of mailboxes configured for this domain */
+    mailboxCount: number;
+}
+export interface Backorder {
+    id?: string;
+    domain?: string;
+    status?: "watching" | "caught" | "failed" | "cancelled" | "expired";
+    payment_method?: "card" | "balance";
+    /** Max USD you'll pay to catch it */
+    max_price?: number;
+    currency?: string;
+    /** Current registration's expiry (informational) */
+    domain_expires?: string | null;
+    last_checked?: string | null;
+    /** Number of availability checks performed */
+    attempts?: number;
+    caught_at?: string | null;
+    /** ID of the Domain created when caught */
+    registered_domain_id?: string | null;
+    failure_reason?: string | null;
+    /** When the watch window ends */
+    expires_at?: string;
+    created_at?: string;
+}
+export interface DealInvoice {
+    deal_id?: string;
+    domain?: string;
+    date?: string;
+    status?: string;
+    your_role?: "buyer" | "seller";
+    currency?: string;
+    line_items?: {
+        description?: string;
+        amount?: number;
+    }[];
+    /** Buyer: amount paid. Seller: net payout after commission. */
+    total?: number;
+    /** Platform commission percent */
+    commission_rate?: number;
+    /** Platform commission in USD */
+    commission_amount?: number;
+    /** Buyer only */
+    payment_method?: string;
+    /** Seller only */
+    payout_method?: "bank" | "balance";
+    /** Seller only */
+    payout_status?: "paid" | "credited" | "pending";
+}
+export interface BrokerRequest {
+    id?: string;
+    domain?: string;
+    status?: "sourcing" | "contacted" | "negotiating" | "agreed" | "completed" | "no_contact" | "declined" | "expired" | "cancelled";
+    /** Your ceiling in USD */
+    max_budget?: number | null;
+    /** Whether the owner has been reached */
+    contacted?: boolean;
+    /** Set once the owner engages and a negotiation opens */
+    negotiation_id?: string | null;
+    failure_reason?: string | null;
+    expires_at?: string;
+    created_at?: string;
+}
+export interface Negotiation {
+    id?: string;
+    domain?: string;
+    status?: "open" | "agreed" | "completed" | "declined" | "expired" | "cancelled";
+    your_role?: "buyer" | "seller";
+    /** True when it's your move to respond */
+    your_turn?: boolean;
+    /** Latest amount on the table (USD) */
+    current_offer?: number;
+    /** Set once the price is agreed */
+    agreed_price?: number | null;
+    /** The listing's asking price (USD) */
+    list_price?: number;
+    expires_at?: string;
+    /** Set once finalized into a deal */
+    deal_id?: string | null;
+    created_at?: string;
+    /** The negotiation thread, oldest first */
+    offers?: {
+        from?: "you" | "counterparty";
+        kind?: "offer" | "counter" | "accept" | "decline";
+        amount?: number | null;
+        message?: string | null;
+        at?: string;
+    }[];
+}
+export interface DomainDetail {
+    domain: string;
+    status: "active" | "expired" | "pending";
+    /** Whether auto-renew is enabled */
+    auto_renew: boolean;
+    purchased_at: string;
+    expires_at: string;
+    /** Days until domain expiry */
+    days_until_expiry: number;
+    /** How the domain was paid for */
+    payment_method: "card" | "x402" | "crypto";
+    /** On-chain tx hash (USDC payments) */
+    payment_tx?: string | null;
+    /** Domain registration details (null if unavailable) */
+    registrar?: {
+        security_lock?: boolean;
+        whois_privacy?: boolean;
+        auto_renew?: boolean;
+        create_date?: string;
+        expire_date?: string;
+    } | null;
+}
+export interface TokenInfo {
+    /** Unique token identifier (use this for DELETE) */
+    id: string;
+    /** Human-readable token label */
+    name: string;
+    /** Masked API key (full key shown only on creation) */
+    key: string;
+    /** Last time this token was used */
+    lastUsed?: string | null;
+    /** When this token expires (null = never) */
+    expiresAt?: string | null;
+    /** Whether this token has expired */
+    expired?: boolean;
+    /** Permission scopes granted to this token. ['*'] means full access. */
+    scopes?: string[];
+    createdAt: string;
+}
+export interface Contact {
+    /** Contact name */
+    name?: string | null;
+    /** Organization name */
+    organization?: string | null;
+    /** Contact email */
+    email?: string | null;
+    /** Phone number */
+    phone?: string | null;
+    /** Fax number */
+    fax?: string | null;
+    /** Street address */
+    street?: string | null;
+    /** City */
+    city?: string | null;
+    /** State or province */
+    state?: string | null;
+    /** Postal/ZIP code */
+    postal_code?: string | null;
+    /** Country code or name */
+    country?: string | null;
+}
+export interface RegistrantContact {
+    /** First name */
+    first_name: string;
+    /** Last name */
+    last_name: string;
+    /** Organization name (optional) */
+    org_name?: string | null;
+    /** Street address line 1 */
+    address1: string;
+    /** Street address line 2 (optional) */
+    address2?: string | null;
+    /** City */
+    city: string;
+    /** State or province */
+    state: string;
+    /** Postal/ZIP code */
+    postal_code: string;
+    /** ISO 3166-1 alpha-2 country code (e.g. US, GB, FR) */
+    country: string;
+    /** Phone in +CC.NUMBER format (e.g. +1.5551234567) */
+    phone: string;
+    /** Contact email address */
+    email: string;
+}
+export interface AccountInfo {
+    id: string;
+    email: string;
+    /** Whether the user has a card on file (required before buying domains) */
+    has_payment_method: boolean;
+    /** Whether the user has set WHOIS contact info (required before purchasing domains) */
+    has_contact: boolean;
+    /** Registrant contact info (null if not set) */
+    contact?: RegistrantContact;
+    /** Your unique referral code */
+    referral_code: string;
+    /** Commission percentage on referred purchases */
+    referral_rate: number;
+    /** Marketplace credit balance in USD (earned from sales) */
+    balance?: number;
+    /** Number of domains owned */
+    domain_count: number;
+    /** Number of active API tokens */
+    token_count: number;
+    created_at: string;
+}
+export declare class Domani {
+    private apiKey;
+    private baseUrl;
+    private fetchImpl;
+    constructor(opts: DomaniOptions);
+    request<T = unknown>(method: string, path: string, opts?: {
+        query?: Record<string, unknown>;
+        body?: unknown;
+    }): Promise<T>;
+    /** Add a mailbox alias (POST /api/emails/{address}/aliases) */
+    addMailboxAlias(address: string, body: {
+        alias: string;
+    }): Promise<{
+        address?: string;
+        mailbox?: string;
+        created_at?: string;
+        hint?: string;
+    }>;
+    /** Add a suppression (POST /api/suppressions) */
+    addSuppression(body: {
+        address: string;
+        reason?: "manual" | "hard_bounce" | "complaint";
+    }): Promise<{
+        address?: string;
+        reason?: string;
+        source?: string;
+        created_at?: string;
+        hint?: string;
+    }>;
+    /** Purchase one or more domains (POST /api/domains/buy) */
+    buyDomain(body: {
+        domain?: string;
+        domains?: string[];
+        payment_method?: "card" | "usdc" | "balance";
+        payment_tx?: string;
+        payment_chain?: "base" | "ethereum";
+        years?: number;
+        ref?: string;
+    }): Promise<{
+        domain?: string;
+        status?: "active";
+        expires?: string;
+        price?: number;
+        currency?: string;
+        years?: number;
+        payment_method?: "card" | "x402" | "crypto";
+        payment_tx?: string;
+        marketplace_purchase?: boolean;
+    }>;
+    /** Cancel a backorder (DELETE /api/backorders/{id}) */
+    cancelBackorder(id: string): Promise<{
+        id?: string;
+        status?: string;
+        hint?: string;
+    }>;
+    /** Cancel a broker request (DELETE /api/broker/{id}) */
+    cancelBrokerRequest(id: string): Promise<{
+        cancelled?: boolean;
+    }>;
+    /** Cancel a domain listing (DELETE /api/domains/{domain}/for-sale) */
+    cancelListing(domain: string): Promise<{
+        domain?: string;
+        status?: "cancelled";
+        hint?: string;
+    }>;
+    /** Withdraw a negotiation (DELETE /api/negotiations/{id}) */
+    cancelNegotiation(id: string): Promise<{
+        cancelled?: boolean;
+    }>;
+    /** Check email DNS health (MX, SPF, DMARC, DKIM) (GET /api/domains/{domain}/email/check) */
+    checkEmail(domain: string): Promise<{
+        domain?: string;
+        provider?: string | null;
+        mx?: {
+            configured?: boolean;
+            records?: string[];
+        };
+        spf?: {
+            configured?: boolean;
+            value?: string | null;
+        };
+        dmarc?: {
+            configured?: boolean;
+            value?: string | null;
+        };
+        dkim?: {
+            configured?: boolean;
+            selectors?: string[];
+        };
+    }>;
+    /** Pre-check transfer eligibility (GET /api/domains/transfer-check) */
+    checkTransferEligibility(query?: {
+        domain: string;
+    }): Promise<{
+        domain: string;
+        tld: string;
+        eligible: boolean;
+        price: number | null;
+        currency: string;
+        reason?: string;
+        code?: "UNSUPPORTED_TLD" | "NOT_AVAILABLE" | "ALREADY_REGISTERED" | "TRANSFER_NOT_ELIGIBLE";
+        eligible_at?: string;
+        hint?: string;
+    }>;
+    /** Check inbound transfer status (GET /api/domains/{domain}/transfer-status) */
+    checkTransferStatus(domain: string): Promise<{
+        domain: string;
+        status: "pending_owner" | "pending_admin" | "pending_registry" | "completed" | "cancelled" | "unknown";
+        timestamp?: string;
+        hint: string;
+    }>;
+    /** Clear domain catch-all (DELETE /api/domains/{domain}/email/catch-all) */
+    clearCatchAll(domain: string): Promise<{
+        domain?: string;
+        catch_all?: string | null;
+        hint?: string;
+    }>;
+    /** Stop forwarding a domain (DELETE /api/domains/{domain}/redirect) */
+    clearDomainRedirect(domain: string): Promise<{
+        domain?: string;
+        redirect_url?: string | null;
+    }>;
+    /** Connect a domain to a hosting or email provider (POST /api/domains/{domain}/connect) */
+    connectDomain(domain: string, body: {
+        target?: string;
+        provider?: string;
+        method?: string;
+    }): Promise<{
+        domain?: string;
+        provider?: string;
+        category?: "hosting" | "email";
+        method?: string;
+        records?: DnsRecord[];
+        docs?: string;
+        status?: "dns_set" | "manual_setup_required";
+        hint?: string;
+        next_steps?: string[];
+    }>;
+    /** Place a backorder on a taken domain (POST /api/backorders) */
+    createBackorder(body: {
+        domain: string;
+        max_price?: number;
+        payment_method?: "card" | "balance";
+    }): Promise<{
+        backorder?: Backorder;
+        hint?: string;
+    }>;
+    /** Request acquisition of a taken domain (POST /api/broker) */
+    createBrokerRequest(body: {
+        domain: string;
+        max_budget?: number;
+    }): Promise<{
+        request?: BrokerRequest;
+    }>;
+    /** Purchase an external domain (create deal) (POST /api/deals) */
+    createDeal(body: {
+        domain: string;
+        payment_method?: "card" | "usdc" | "balance";
+    }): Promise<{
+        deal?: Record<string, unknown>;
+        hint?: string;
+        next_steps?: string[];
+    }>;
+    /** List a domain for sale (PUT /api/domains/{domain}/for-sale) */
+    createListing(domain: string, body: {
+        price: number;
+        description?: string;
+    }): Promise<{
+        listing?: {
+            id?: string;
+            domain?: string;
+            price?: number;
+            currency?: string;
+            description?: string | null;
+            status?: "active";
+            created_at?: string;
+        };
+        hint?: string;
+    }>;
+    /** Create a mailbox on domani.run (POST /api/email) */
+    createMailbox(body: {
+        slug: string;
+        name?: string;
+    }): Promise<{
+        id?: string;
+        address?: string;
+        slug?: string;
+        domain?: string;
+    }>;
+    /** Create a mailbox (POST /api/emails) */
+    createMailboxByAddress(body?: {
+        address: string;
+        name?: string;
+        force?: boolean;
+    }): Promise<{
+        id?: string;
+        address?: string;
+        name?: string | null;
+        domain?: string;
+        slug?: string;
+        webhook_url?: string | null;
+        forward_to?: string | null;
+        signing_secret?: string;
+    }>;
+    /** Create a new API token (POST /api/tokens) */
+    createToken(body: {
+        name?: string;
+        expires_in?: number;
+        expires_at?: string;
+        scopes?: string[];
+    }): Promise<{
+        id?: string;
+        name?: string;
+        key?: string;
+        expiresAt?: string | null;
+        scopes?: string[];
+        createdAt?: string;
+    }>;
+    /** Create webhook (POST /api/webhooks) */
+    createWebhook(body: {
+        url: string;
+        events: string[];
+    }): Promise<{
+        id?: string;
+        url?: string;
+        events?: string[];
+        secret?: string;
+        active?: boolean;
+        created_at?: string;
+        hint?: string;
+    }>;
+    /** Delete account and all associated data (DELETE /api/me) */
+    deleteAccount(): Promise<{
+        deleted?: boolean;
+        hint?: string;
+    }>;
+    /** Delete a mailbox (DELETE /api/emails/{address}) */
+    deleteMailboxByAddress(address: string, body?: {
+        confirm?: boolean;
+    }): Promise<unknown>;
+    /** Delete a message (DELETE /api/emails/{address}/messages/{id}) */
+    deleteMessageByAddress(address: string, id: string): Promise<{
+        id?: string;
+        deleted?: boolean;
+    }>;
+    /** Bulk delete messages (POST /api/emails/{address}/messages/delete) */
+    deleteMessagesByAddress(address: string, body?: {
+        message_ids: string[];
+    }): Promise<{
+        count?: number;
+    }>;
+    /** Delete webhook (DELETE /api/webhooks/{id}) */
+    deleteWebhook(id: string): Promise<{
+        success?: boolean;
+        hint?: string;
+    }>;
+    /** Fast DNS-based domain existence check (GET /api/domains/dns-check) */
+    dnsCheck(query?: {
+        name: string;
+        tlds: string;
+    }): Promise<{
+        name?: string;
+        taken?: string[];
+        candidates?: string[];
+    }>;
+    /** Finalize an agreed negotiation (pay) (POST /api/negotiations/{id}/finalize) */
+    finalizeNegotiation(id: string, body?: {
+        payment_method?: "card" | "usdc" | "balance";
+        payment_signature?: string | null;
+        payment_tx?: string;
+        payment_chain?: string;
+        confirm_over_budget?: boolean;
+    }): Promise<unknown>;
+    /** Forward a message (POST /api/emails/{address}/messages/{id}/forward) */
+    forwardMessageByAddress(address: string, id: string, body?: {
+        to: string;
+        text?: string;
+    }): Promise<{
+        id?: string;
+        message_id?: string;
+        from?: string;
+        to?: string;
+        status?: string;
+    }>;
+    /** Get current account details (GET /api/me) */
+    getAccount(): Promise<AccountInfo>;
+    /** Get EPP auth code (GET /api/domains/{domain}/auth-code) */
+    getAuthCode(domain: string): Promise<{
+        domain: string;
+        auth_code: string;
+        was_unlocked: boolean;
+        hint: string;
+        next_steps: string[];
+    }>;
+    /** Get a backorder (GET /api/backorders/{id}) */
+    getBackorder(id: string): Promise<{
+        backorder?: Backorder;
+    }>;
+    /** Read a broker inquiry's state (owner side) (GET /api/broker/respond) */
+    getBrokerInquiryState(query?: {
+        token: string;
+    }): Promise<{
+        domain?: string;
+        status?: string;
+        your_turn?: boolean;
+        current_offer_usd?: number | null;
+        agreed_price_usd?: number | null;
+        actions?: string[];
+    }>;
+    /** Get a broker request (GET /api/broker/{id}) */
+    getBrokerRequest(id: string): Promise<{
+        request?: BrokerRequest;
+    }>;
+    /** Get registrant contact info (GET /api/me/contact) */
+    getContact(): Promise<{
+        has_contact?: boolean;
+        contact?: RegistrantContact;
+    }>;
+    /** Get deal detail with timeline (GET /api/deals/{id}) */
+    getDeal(id: string): Promise<{
+        deal?: {
+            id?: string;
+            domain?: string;
+            price?: number;
+            currency?: string;
+            fee?: number;
+            seller_credit?: number;
+            status?: "escrow_held" | "epp_pending" | "transfer_started" | "completed" | "refunded" | "expired";
+            role?: "buyer" | "seller";
+            payment_method?: string;
+            epp_deadline?: string | null;
+            transfer_deadline?: string | null;
+            completed_at?: string | null;
+            created_at?: string;
+            events?: {
+                status?: string;
+                detail?: string | null;
+                created_at?: string;
+            }[];
+        };
+        hint?: string;
+    }>;
+    /** Get a deal receipt / statement (GET /api/deals/{id}/invoice) */
+    getDealInvoice(id: string): Promise<{
+        invoice?: DealInvoice;
+    }>;
+    /** Get DNS records for a domain you own (GET /api/domains/{domain}/dns) */
+    getDnsRecords(domain: string): Promise<{
+        domain?: string;
+        records?: DnsRecord[];
+    }>;
+    /** Check email DNS status (GET /api/domains/{domain}/email/status) */
+    getDomainEmailStatus(domain: string): Promise<{
+        domain?: string;
+        verified?: boolean;
+        records?: DnsRecord[];
+        mailbox_count?: number;
+    }>;
+    /** Get detailed information about a domain you own (GET /api/domains/{domain}) */
+    getDomainInfo(domain: string): Promise<DomainDetail>;
+    /** Get website preview metadata for a domain (GET /api/domains/{domain}/og) */
+    getDomainOg(domain: string): Promise<{
+        title: string | null;
+        description: string | null;
+        image: string | null;
+        favicon: string | null;
+    }>;
+    /** Check domain health: DNS, SSL, email, expiry (GET /api/domains/{domain}/status) */
+    getDomainStatus(domain: string): Promise<{
+        domain?: string;
+        status?: string;
+        expires?: string;
+        days_until_expiry?: number;
+        dns?: {
+            propagated?: boolean;
+            a?: string[];
+            aaaa?: string[];
+            cname?: string[];
+            mx?: string[];
+            txt?: string[];
+            ns?: string[];
+            registrar_records?: DnsRecord[];
+        };
+        ssl?: {
+            active?: boolean;
+        };
+        email?: {
+            configured?: boolean;
+            mx?: string[];
+        };
+    }>;
+    /** Get mailbox avatar info (GET /api/emails/{address}/avatar) */
+    getMailboxAvatarByAddress(address: string): Promise<{
+        address?: string;
+        gravatar_url?: string | null;
+        gravatar_signup?: string;
+        has_avatar?: boolean;
+        hint?: string;
+    }>;
+    /** Get mailbox details (GET /api/emails/{address}) */
+    getMailboxByAddress(address: string): Promise<{
+        id?: string;
+        address?: string;
+        slug?: string;
+        domain?: string;
+        webhook_url?: string | null;
+        forward_to?: string | null;
+        signing_secret?: string;
+        message_count?: number;
+        created_at?: string;
+    }>;
+    /** Get mailbox webhook config (GET /api/emails/{address}/webhook) */
+    getMailboxWebhook(address: string): Promise<{
+        address?: string;
+        webhook_url?: string | null;
+        signing_secret?: string | null;
+        has_webhook?: boolean;
+        hint?: string;
+    }>;
+    /** Get a message (GET /api/emails/{address}/messages/{id}) */
+    getMessageByAddress(address: string, id: string): Promise<{
+        id?: string;
+        message_id?: string | null;
+        direction?: "in" | "out";
+        from?: string;
+        to?: string;
+        cc?: string | null;
+        reply_to?: string | null;
+        subject?: string;
+        text?: string | null;
+        html?: string | null;
+        in_reply_to?: string | null;
+        references?: string | null;
+        attachments?: {
+            filename?: string;
+            content_type?: string;
+            size?: number;
+            url?: string | null;
+        }[];
+        status?: string;
+        is_read?: boolean;
+        read_at?: string | null;
+        events?: {
+            status?: string;
+            detail?: Record<string, unknown> | null;
+            created_at?: string;
+        }[];
+        created_at?: string;
+    }>;
+    /** Get nameservers for a domain (GET /api/domains/{domain}/nameservers) */
+    getNameservers(domain: string): Promise<{
+        domain?: string;
+        nameservers?: string[];
+        default_nameservers?: string[] | null;
+        hint?: string;
+    }>;
+    /** Get a negotiation thread (GET /api/negotiations/{id}) */
+    getNegotiation(id: string): Promise<{
+        negotiation?: Negotiation;
+    }>;
+    /** Get notification preferences (GET /api/notifications/preferences) */
+    getNotificationPreferences(): Promise<{
+        preferences?: {
+            category?: "domains" | "transfers" | "marketplace" | "email" | "inquiries";
+            label?: string;
+            description?: string;
+            channel?: "in_app" | "email";
+            enabled?: boolean;
+        }[];
+    }>;
+    /** Get parking analytics (GET /api/domains/{domain}/analytics) */
+    getParkingAnalytics(domain: string): Promise<{
+        domain?: string;
+        views_7d?: number;
+        views_30d?: number;
+        inquiries_30d?: number;
+        conversion_rate?: number;
+        daily_views?: {
+            date?: string;
+            views?: number;
+        }[];
+        recent_inquiries?: {
+            email?: string;
+            offer?: number | null;
+            date?: string;
+        }[];
+        hint?: string;
+    }>;
+    /** Get marketplace payout status (GET /api/billing/connect) */
+    getPayoutStatus(): Promise<{
+        onboarded?: boolean;
+        payouts_enabled?: boolean;
+        details_submitted?: boolean;
+        balance_cents?: number;
+    }>;
+    /** Get referral earnings and history (GET /api/referrals) */
+    getReferrals(): Promise<{
+        referral_code?: string;
+        referral_rate?: number;
+        total_earned_cents?: number;
+        total_paid_cents?: number;
+        total_pending_cents?: number;
+        referrals?: {
+            id?: string;
+            domains?: string[];
+            earned_cents?: number;
+            paid_out?: boolean;
+            created_at?: string;
+        }[];
+    }>;
+    /** Check listing and deal status (GET /api/domains/sell/status) */
+    getSellStatus(query?: {
+        domain: string;
+    }): Promise<{
+        listing?: Record<string, unknown> | null;
+        deal?: Record<string, unknown> | null;
+        hint?: string;
+    }>;
+    /** Get outbound transfer status (GET /api/domains/{domain}/transfer-away) */
+    getTransferAway(domain: string): Promise<{
+        domain: string;
+        status: "none" | "pending" | "approved" | "completed" | "rejected" | "expired";
+        gaining_registrar?: string;
+        request_date?: string;
+        hint: string;
+    }>;
+    /** Get unread notification count (GET /api/notifications/count) */
+    getUnreadCount(): Promise<{
+        unread_count?: number;
+    }>;
+    /** List webhook deliveries (GET /api/webhooks/{id}/deliveries) */
+    getWebhookDeliveries(id: string, query?: {
+        limit?: number;
+    }): Promise<{
+        deliveries?: {
+            id?: string;
+            event_type?: string;
+            status?: "pending" | "delivered" | "failed";
+            http_status?: number | null;
+            attempts?: number;
+            last_error?: string | null;
+            created_at?: string;
+        }[];
+        hint?: string;
+    }>;
+    /** Import an external domain (POST /api/domains/import) */
+    importDomain(body: {
+        domain: string;
+    }): Promise<{
+        domain?: string;
+        status?: string;
+        token?: string;
+        txt_record?: {
+            type?: string;
+            name?: string;
+            value?: string;
+        };
+        hint?: string;
+    }>;
+    /** List your backorders (GET /api/backorders) */
+    listBackorders(query?: {
+        status?: "watching" | "caught" | "failed" | "cancelled" | "expired";
+    }): Promise<{
+        backorders?: Backorder[];
+    }>;
+    /** List your broker requests (GET /api/broker) */
+    listBrokerRequests(query?: {
+        status?: string;
+    }): Promise<{
+        requests?: BrokerRequest[];
+    }>;
+    /** List available providers for connecting a domain (GET /api/domains/{domain}/connect) */
+    listConnectProviders(domain: string): Promise<{
+        domain?: string;
+        providers?: {
+            hosting?: Record<string, unknown>[];
+            email?: Record<string, unknown>[];
+        };
+    }>;
+    /** List your deals (GET /api/deals) */
+    listDeals(query?: {
+        role?: "buyer" | "seller";
+        status?: "active" | "escrow_held" | "epp_pending" | "transfer_started" | "completed" | "refunded" | "expired";
+        domain?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        deals?: {
+            id?: string;
+            domain?: string;
+            price?: number;
+            currency?: string;
+            status?: string;
+            role?: "buyer" | "seller";
+            payment_method?: string;
+            epp_deadline?: string | null;
+            transfer_deadline?: string | null;
+            created_at?: string;
+        }[];
+        has_more?: boolean;
+        next_cursor?: string | null;
+    }>;
+    /** List all your registered domains (GET /api/domains) */
+    listDomains(): Promise<{
+        domains?: DomainRecord[];
+    }>;
+    /** List emails (GET /api/emails/{address}/messages) */
+    listEmailMessagesByAddress(address: string, query?: {
+        cursor?: string;
+        limit?: number;
+        direction?: "in" | "out" | "all";
+        since?: string;
+        from?: string;
+        to?: string;
+        subject?: string;
+    }): Promise<{
+        messages?: {
+            id?: string;
+            message_id?: string | null;
+            direction?: "in" | "out";
+            from?: string;
+            to?: string;
+            cc?: string | null;
+            reply_to?: string | null;
+            subject?: string;
+            text?: string;
+            in_reply_to?: string | null;
+            references?: string | null;
+            status?: "queued" | "sent" | "delivered" | "delayed" | "bounced" | "failed" | "complained" | "suppressed";
+            events?: {
+                status?: string;
+                detail?: Record<string, unknown> | null;
+                created_at?: string;
+            }[];
+            created_at?: string;
+        }[];
+        next_cursor?: string | null;
+        has_more?: boolean;
+    }>;
+    /** List payment invoices (GET /api/billing/invoices) */
+    listInvoices(query?: {
+        limit?: number;
+    }): Promise<{
+        invoices?: {
+            id?: string;
+            number?: string | null;
+            status?: string;
+            amount_due?: number;
+            amount_paid?: number;
+            currency?: string;
+            description?: string | null;
+            created?: string;
+            hosted_invoice_url?: string | null;
+            invoice_pdf?: string | null;
+        }[];
+        has_more?: boolean;
+        hint?: string;
+    }>;
+    /** List mailbox aliases (GET /api/emails/{address}/aliases) */
+    listMailboxAliases(address: string): Promise<{
+        mailbox?: string;
+        aliases?: {
+            address?: string;
+            created_at?: string;
+        }[];
+        hint?: string;
+    }>;
+    /** List all mailboxes (GET /api/email) */
+    listMailboxes(query?: {
+        domain?: string;
+    }): Promise<{
+        mailboxes?: {
+            id?: string;
+            address?: string;
+            slug?: string;
+            domain?: string;
+            message_count?: number;
+        }[];
+    }>;
+    /** List all mailboxes (GET /api/emails) */
+    listMailboxesByAddress(query?: {
+        domain?: string;
+    }): Promise<{
+        mailboxes?: {
+            id?: string;
+            address?: string;
+            slug?: string;
+            domain?: string;
+            message_count?: number;
+            webhook_url?: string | null;
+            forward_to?: string | null;
+        }[];
+    }>;
+    /** List your negotiations (GET /api/negotiations) */
+    listNegotiations(query?: {
+        role?: "buyer" | "seller";
+        status?: string;
+    }): Promise<{
+        negotiations?: Negotiation[];
+    }>;
+    /** List notifications (GET /api/notifications) */
+    listNotifications(query?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        notifications?: {
+            id?: string;
+            type?: string;
+            title?: string;
+            body?: string;
+            action_url?: string | null;
+            read?: boolean;
+            created_at?: string;
+        }[];
+        has_more?: boolean;
+        next_cursor?: string | null;
+    }>;
+    /** List suppressed addresses (GET /api/suppressions) */
+    listSuppressions(query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        suppressions?: {
+            address?: string;
+            reason?: "hard_bounce" | "complaint" | "manual";
+            source?: "resend" | "api";
+            created_at?: string;
+        }[];
+        next_cursor?: string | null;
+        hint?: string;
+    }>;
+    /** List all available TLDs with pricing (GET /api/tlds) */
+    listTlds(query?: {
+        max_price?: number;
+        min_price?: number;
+        sort?: "tld" | "price" | "renewal";
+        order?: "asc" | "desc";
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        tlds?: TldInfo[];
+        total?: number;
+        offset?: number;
+        limit?: number | null;
+    }>;
+    /** List your API tokens (GET /api/tokens) */
+    listTokens(): Promise<{
+        tokens?: TokenInfo[];
+    }>;
+    /** List supported services for domain verification (GET /api/domains/{domain}/verify-service) */
+    listVerifyServices(domain: string): Promise<{
+        domain?: string;
+        services?: {
+            name?: string;
+            displayName?: string;
+            description?: string;
+            docs?: string;
+        }[];
+        hint?: string;
+    }>;
+    /** List webhook event types (GET /api/webhooks/events) */
+    listWebhookEvents(): Promise<{
+        events?: {
+            type?: string;
+            description?: string;
+        }[];
+    }>;
+    /** List webhooks (GET /api/webhooks) */
+    listWebhooks(): Promise<{
+        webhooks?: {
+            id?: string;
+            url?: string;
+            events?: string[];
+            active?: boolean;
+            created_at?: string;
+        }[];
+        hint?: string;
+    }>;
+    /** Send a magic link sign-in email (POST /api/auth/login) */
+    loginUser(body: {
+        email: string;
+    }): Promise<{
+        ok?: boolean;
+        message?: string;
+    }>;
+    /** Make an offer on a listing (POST /api/negotiations) */
+    makeOffer(body: {
+        domain: string;
+        offer: number;
+        message?: string;
+    }): Promise<{
+        negotiation?: Negotiation;
+    }>;
+    /** Mark all notifications as read (POST /api/notifications/read-all) */
+    markAllNotificationsRead(): Promise<{
+        ok?: boolean;
+        count?: number;
+    }>;
+    /** Mark messages as read or unread (PATCH /api/emails/{address}/messages/read) */
+    markMessagesReadByAddress(address: string, body?: {
+        message_ids: string[];
+        read: boolean;
+    }): Promise<{
+        count?: number;
+    }>;
+    /** Mark notification as read (PATCH /api/notifications/{id}) */
+    markNotificationRead(id: string, body: {
+        read: boolean;
+    }): Promise<{
+        ok?: boolean;
+    }>;
+    /** Provide EPP/auth code (seller) (PATCH /api/deals/{id}) */
+    provideEppCode(id: string, body: {
+        auth_code: string;
+    }): Promise<{
+        deal?: Record<string, unknown>;
+        hint?: string;
+    }>;
+    /** Provision a complete agent identity in one call (POST /api/agents/provision) */
+    provisionAgent(body: {
+        domain: string;
+        slug?: string;
+        name?: string;
+        webhook_url?: string;
+        webhook_events?: string[];
+        payment_method?: "card" | "usdc" | "balance";
+        payment_tx?: string;
+        payment_chain?: "base" | "ethereum";
+        years?: number;
+    }): Promise<unknown>;
+    /** Create a new account (POST /api/auth/register) */
+    registerUser(body: {
+        email: string;
+        ref?: string;
+    }): Promise<{
+        api_key?: string;
+        referral_code?: string;
+        has_payment_method?: boolean;
+        user?: {
+            id?: string;
+            email?: string;
+        };
+    }>;
+    /** Remove saved payment method (DELETE /api/billing/card) */
+    removeCard(): Promise<{
+        removed?: boolean;
+    }>;
+    /** Remove email from a domain (DELETE /api/domains/{domain}/email/setup) */
+    removeDomainEmail(domain: string): Promise<unknown>;
+    /** Remove a mailbox alias (DELETE /api/emails/{address}/aliases/{alias}) */
+    removeMailboxAlias(address: string, alias: string): Promise<{
+        address?: string;
+        deleted?: boolean;
+        hint?: string;
+    }>;
+    /** Remove mailbox webhook (DELETE /api/emails/{address}/webhook) */
+    removeMailboxWebhook(address: string): Promise<{
+        address?: string;
+        webhook_url?: string | null;
+        signing_secret?: string | null;
+        has_webhook?: boolean;
+        hint?: string;
+    }>;
+    /** Remove a suppression (DELETE /api/suppressions/{address}) */
+    removeSuppression(address: string): Promise<{
+        address?: string;
+        deleted?: boolean;
+        hint?: string;
+    }>;
+    /** Renew a domain (POST /api/domains/{domain}/renew) */
+    renewDomain(domain: string, body?: {
+        years?: number;
+        payment_method?: "card" | "usdc" | "balance";
+        payment_tx?: string;
+        payment_chain?: "base" | "ethereum";
+    }): Promise<{
+        domain: string;
+        renewed_years: number;
+        new_expiry: string;
+        price: number;
+        currency: string;
+        payment_method: string;
+        payment_tx?: string;
+    }>;
+    /** Reply to a message (POST /api/emails/{address}/messages/{id}/reply) */
+    replyToMessageByAddress(address: string, id: string, body?: {
+        text?: string;
+        html?: string;
+        cc?: string | string[];
+        all?: boolean;
+    }): Promise<{
+        id?: string;
+        message_id?: string;
+        from?: string;
+        to?: string;
+        status?: string;
+    }>;
+    /** Resend contact email verification (POST /api/me/resend-verification) */
+    resendEmailVerification(body?: {
+        email?: string;
+    }): Promise<{
+        sent?: boolean;
+        already_verified?: boolean;
+        hint?: string;
+    }>;
+    /** Respond to a broker inquiry (owner side) (POST /api/broker/respond) */
+    respondToBrokerInquiry(body: {
+        token: string;
+        action: "offer" | "counter" | "accept" | "decline" | "opt_out";
+        price?: number;
+    }): Promise<{
+        handled?: boolean;
+        outcome?: string;
+        status?: string;
+        negotiation_id?: string;
+        domain?: string;
+    }>;
+    /** Counter, accept, or decline (POST /api/negotiations/{id}) */
+    respondToNegotiation(id: string, body: {
+        action: "counter" | "accept" | "decline";
+        counter?: number;
+        message?: string;
+    }): Promise<{
+        negotiation?: Negotiation;
+    }>;
+    /** Restore DNS from a snapshot (POST /api/domains/{domain}/dns/restore) */
+    restoreDns(domain: string, body?: {
+        snapshot?: {
+            domain?: string;
+            records?: DnsRecord[];
+            subdomains?: string[];
+            sources?: string[];
+            capturedAt?: string;
+        };
+    }): Promise<{
+        domain?: string;
+        applied?: number;
+        skipped?: number;
+        recordCount?: number;
+        errors?: string[];
+    }>;
+    /** Revoke an API token (DELETE /api/tokens/{id}) */
+    revokeToken(id: string): Promise<{
+        success?: boolean;
+    }>;
+    /** Rotate webhook signing secret (POST /api/emails/{address}/webhook/rotate) */
+    rotateMailboxWebhookSecret(address: string): Promise<{
+        address?: string;
+        webhook_url?: string;
+        signing_secret?: string;
+        has_webhook?: boolean;
+        hint?: string;
+    }>;
+    /** Check availability and pricing for domains (GET /api/domains/search) */
+    search(query?: {
+        q?: string;
+        domains?: string;
+        max_price?: number;
+        sort?: "price" | "tld";
+        source?: "all" | "primary" | "secondary";
+        order?: "asc" | "desc";
+    }): Promise<SearchResult>;
+    /** List a domain for sale (open marketplace) (POST /api/domains/sell) */
+    sellDomain(body: {
+        domain: string;
+        price: number;
+        description?: string;
+    }): Promise<{
+        listing?: {
+            id?: string;
+            domain?: string;
+            price?: number;
+            currency?: string;
+            status?: "active" | "pending_verification";
+            description?: string | null;
+            created_at?: string;
+        };
+        txt_record?: {
+            type?: "TXT";
+            name?: string;
+            value?: string;
+        } | null;
+        hint?: string;
+    }>;
+    /** Send an email (POST /api/emails/{address}/send) */
+    sendEmailByAddress(address: string, body?: {
+        to: string;
+        cc?: string | string[];
+        bcc?: string | string[];
+        subject?: string;
+        text?: string;
+        html?: string;
+        reply_to?: string;
+        in_reply_to?: string;
+        references?: string;
+        attachments?: {
+            content: string;
+            filename: string;
+            content_type?: string;
+        }[];
+    }): Promise<{
+        id?: string;
+        message_id?: string;
+        from?: string;
+        to?: string;
+        status?: string;
+        attachments_count?: number;
+    }>;
+    /** Set domain catch-all (PUT /api/domains/{domain}/email/catch-all) */
+    setCatchAll(domain: string, body: {
+        mailbox: string;
+    }): Promise<{
+        domain?: string;
+        catch_all?: string | null;
+        hint?: string;
+    }>;
+    /** Set registrant contact info (PUT /api/me/contact) */
+    setContact(body: RegistrantContact): Promise<{
+        contact?: RegistrantContact;
+    }>;
+    /** Set DNS records for a domain you own (PUT /api/domains/{domain}/dns) */
+    setDnsRecords(domain: string, body: {
+        records: DnsRecord[];
+    }): Promise<{
+        success?: boolean;
+        domain?: string;
+        records?: DnsRecord[];
+    }>;
+    /** Forward a domain to a URL (PUT /api/domains/{domain}/redirect) */
+    setDomainRedirect(domain: string, body: {
+        url: string;
+        permanent?: boolean;
+    }): Promise<{
+        domain?: string;
+        redirect_url?: string | null;
+        permanent?: boolean;
+    }>;
+    /** Set mailbox webhook (PUT /api/emails/{address}/webhook) */
+    setMailboxWebhook(address: string, body: {
+        url: string;
+    }): Promise<{
+        address?: string;
+        webhook_url?: string;
+        signing_secret?: string;
+        has_webhook?: boolean;
+        hint?: string;
+    }>;
+    /** Set nameservers for a domain (PUT /api/domains/{domain}/nameservers) */
+    setNameservers(domain: string, body: {
+        nameservers: string[];
+    }): Promise<{
+        success?: boolean;
+        domain?: string;
+        nameservers?: string[];
+        hint?: string;
+    }>;
+    /** Get checkout URL for adding a payment method (POST /api/billing/setup) */
+    setupBilling(body?: {
+        mode?: "setup_intent" | "checkout";
+    }): Promise<{
+        url?: string;
+        client_secret?: string;
+        hint?: string;
+    }>;
+    /** Set up email on a domain (POST /api/domains/{domain}/email/setup) */
+    setupDomainEmail(domain: string, body?: {
+        force?: boolean;
+    }): Promise<{
+        domain?: string;
+        status?: "configured" | "already_configured";
+        verified_at?: string | null;
+        records?: DnsRecord[];
+        hint?: string;
+    }>;
+    /** Capture a DNS snapshot (POST /api/domains/{domain}/dns/snapshot) */
+    snapshotDns(domain: string, body?: {
+        extra_subdomains?: string[];
+    }): Promise<{
+        domain?: string;
+        records?: DnsRecord[];
+        subdomains?: string[];
+        sources?: string[];
+        capturedAt?: string;
+    }>;
+    /** Start bank payout onboarding (POST /api/billing/connect) */
+    startPayoutOnboarding(): Promise<{
+        url?: string;
+    }>;
+    /** AI-powered domain suggestions with availability (GET /api/domains/suggest) */
+    suggestDomains(query?: {
+        prompt: string;
+        count?: number;
+        exclude?: string;
+        tlds?: string;
+        style?: "single" | "creative" | "short" | "brandable" | "keyword";
+        lang?: "japanese" | "spanish" | "french" | "italian" | "latin" | "nordic" | "arabic" | "sanskrit";
+    }): Promise<{
+        suggestions: {
+            domain: string;
+            price: number;
+            currency: string;
+        }[];
+        checked: number;
+        iterations: number;
+    }>;
+    /** Test mailbox webhook (POST /api/emails/{address}/webhook/test) */
+    testMailboxWebhook(address: string): Promise<{
+        address?: string;
+        webhook_url?: string;
+        status?: number;
+        success?: boolean;
+        hint?: string;
+    }>;
+    /** Transfer domain from another provider (POST /api/domains/transfer) */
+    transferDomain(body: {
+        domain: string;
+        auth_code: string;
+        payment_method?: "card" | "usdc" | "balance";
+        payment_tx?: string;
+        payment_chain?: "base" | "ethereum";
+        extra_subdomains?: string[];
+    }): Promise<unknown>;
+    /** Update account preferences (PUT /api/me) */
+    updateAccount(body: {
+        preferred_payment_method: "card" | "usdc" | null;
+    }): Promise<{
+        preferred_payment_method?: string | null;
+        hint?: string;
+    }>;
+    /** Update domain settings (PUT /api/domains/{domain}/settings) */
+    updateDomainSettings(domain: string, body: {
+        auto_renew?: boolean;
+        whois_privacy?: boolean;
+        security_lock?: boolean;
+    }): Promise<{
+        domain: string;
+        auto_renew?: boolean;
+        whois_privacy?: boolean;
+        security_lock?: boolean;
+        hint: string;
+    }>;
+    /** Update a domain listing (PATCH /api/domains/{domain}/for-sale) */
+    updateListing(domain: string, body: {
+        price?: number;
+        description?: string | null;
+    }): Promise<{
+        listing?: {
+            id?: string;
+            domain?: string;
+            price?: number;
+            currency?: string;
+            description?: string | null;
+            status?: "active";
+            created_at?: string;
+        };
+        hint?: string;
+    }>;
+    /** Update mailbox (PATCH /api/emails/{address}) */
+    updateMailboxByAddress(address: string, body?: {
+        name?: string | null;
+        webhook_url?: string | null;
+        forward_to?: string | null;
+    }): Promise<{
+        id?: string;
+        address?: string;
+        slug?: string;
+        domain?: string;
+        name?: string | null;
+        webhook_url?: string | null;
+        forward_to?: string | null;
+        signing_secret?: string;
+    }>;
+    /** Update notification preferences (PUT /api/notifications/preferences) */
+    updateNotificationPreferences(body: {
+        preferences: {
+            category: "domains" | "transfers" | "marketplace" | "email" | "inquiries";
+            channel: "in_app" | "email";
+            enabled: boolean;
+        }[];
+    }): Promise<{
+        ok?: boolean;
+    }>;
+    /** Update parking settings (PUT /api/domains/{domain}/parking) */
+    updateParking(domain: string, body: {
+        enabled?: boolean;
+        listing_price?: number | null;
+    }): Promise<{
+        domain?: string;
+        parking_enabled?: boolean;
+        listing_price?: number | null;
+        hint?: string;
+    }>;
+    /** Update webhook (PATCH /api/webhooks/{id}) */
+    updateWebhook(id: string, body: {
+        url?: string;
+        events?: string[];
+        active?: boolean;
+    }): Promise<{
+        id?: string;
+        url?: string;
+        events?: string[];
+        active?: boolean;
+        hint?: string;
+    }>;
+    /** Verify that a provider connection is working (POST /api/domains/{domain}/verify) */
+    verifyConnection(domain: string, body: {
+        target?: string;
+        provider?: string;
+        method?: string;
+    }): Promise<{
+        domain?: string;
+        provider?: string;
+        method?: string;
+        verified?: boolean;
+        message?: string;
+        hint?: string;
+        next_steps?: string[];
+    }>;
+    /** Verify and complete domain import (POST /api/domains/import/verify) */
+    verifyImport(body: {
+        domain: string;
+    }): Promise<{
+        domain?: string;
+        status?: string;
+        expires?: string;
+        registrar?: string;
+        payment_method?: string;
+        hint?: string;
+    }>;
+    /** Verify a magic link token (GET /api/auth/verify) */
+    verifyMagicLink(query?: {
+        token: string;
+    }): Promise<unknown>;
+    /** Verify TXT ownership for external listing (POST /api/domains/sell/verify) */
+    verifySellListing(body: {
+        domain: string;
+    }): Promise<{
+        listing?: Record<string, unknown>;
+        hint?: string;
+    }>;
+    /** Add DNS records to verify domain ownership for a third-party service (POST /api/domains/{domain}/verify-service) */
+    verifyService(domain: string, body: {
+        service: string;
+        token: string;
+    }): Promise<{
+        domain?: string;
+        service?: string;
+        service_display_name?: string;
+        known_service?: boolean;
+        records_added?: DnsRecord[];
+        total_records?: number;
+        docs?: string | null;
+        hint?: string;
+    }>;
+    /** Watch a domain for transfer eligibility (POST /api/domains/transfer-watch) */
+    watchTransfer(body: {
+        domain: string;
+    }): Promise<{
+        domain: string;
+        eligible: boolean;
+        eligible_at?: string;
+        hint?: string;
+        watching: boolean;
+    }>;
+    /** Look up domain registration data via RDAP (GET /api/domains/whois) */
+    whoisLookup(query?: {
+        q: string;
+    }): Promise<{
+        domain: string;
+        registered: boolean;
+        registrar: string | null;
+        registrar_url: string | null;
+        registrar_iana_id: string | null;
+        created: string | null;
+        expires: string | null;
+        updated: string | null;
+        days_until_expiry: number | null;
+        status: string[];
+        nameservers: string[];
+        dnssec: boolean;
+        redacted: boolean;
+        contacts: {
+            registrant: Contact | unknown;
+            admin: Contact | unknown;
+            tech: Contact | unknown;
+            billing: Contact | unknown;
+            abuse: Contact | unknown;
+        };
+    }>;
+    /** Withdraw marketplace balance to bank (POST /api/billing/connect/payout) */
+    withdrawBalance(): Promise<{
+        amount_cents?: number;
+        transfer_id?: string;
+    }>;
+}
+export default Domani;